-/* $PostgreSQL: pgsql/src/interfaces/ecpg/compatlib/informix.c,v 1.54 2008/01/08 01:14:52 tgl Exp $ */
+/* $PostgreSQL: pgsql/src/interfaces/ecpg/compatlib/informix.c,v 1.55 2008/05/16 15:20:03 petere Exp $ */
#define POSTGRES_ECPG_INTERNAL
#include "postgres_fe.h"
sqlca->sqlcode = ECPG_OUT_OF_MEMORY;
strncpy(sqlca->sqlstate, "YE001", sizeof("YE001"));
- snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc), "Out of memory in line %d.", lineno);
+ 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();
-/* $PostgreSQL: pgsql/src/interfaces/ecpg/ecpglib/connect.c,v 1.50 2008/03/27 07:56:00 meskes Exp $ */
+/* $PostgreSQL: pgsql/src/interfaces/ecpg/ecpglib/connect.c,v 1.51 2008/05/16 15:20:03 petere Exp $ */
#define POSTGRES_ECPG_INTERNAL
#include "postgres_fe.h"
if (actual_connection == act)
actual_connection = all_connections;
- ecpg_log("ecpg_finish: Connection %s closed.\n", act->name);
+ ecpg_log("ecpg_finish: connection %s closed\n", act->name);
for (cache = act->cache_head; cache; ptr = cache, cache = cache->next, ecpg_free(ptr));
ecpg_free(act->name);
ecpg_free(act);
}
else
- ecpg_log("ecpg_finish: called an extra time.\n");
+ ecpg_log("ecpg_finish: called an extra time\n");
}
bool
if (!ecpg_init(con, connection_name, lineno))
return (false);
- ecpg_log("ECPGsetcommit line %d action = %s connection = %s\n", lineno, mode, con->name);
+ ecpg_log("ECPGsetcommit on line %d: action \"%s\"; connection \"%s\"\n", lineno, mode, con->name);
if (con->autocommit == true && strncmp(mode, "off", strlen("off")) == 0)
{
sqlstate = ECPG_SQLSTATE_ECPG_INTERNAL_ERROR;
if (message == NULL) /* Shouldn't happen, but need to be sure */
- message = "No message received";
+ message = _("No message received");
/* these are not warnings */
if (strncmp(sqlstate, "00", 2) == 0)
return;
- ecpg_log("ECPGnoticeReceiver %s\n", message);
+ ecpg_log("ECPGnoticeReceiver: %s\n", message);
/* map to SQLCODE for backward compatibility */
if (strcmp(sqlstate, ECPG_SQLSTATE_INVALID_CURSOR_NAME) == 0)
host = ecpg_strdup(tmp + 1, lineno);
if (strncmp(dbname, "unix:", 5) != 0)
{
- ecpg_log("ECPGconnect: socketname %s given for TCP connection in line %d\n", host, lineno);
- ecpg_raise(lineno, ECPG_CONNECT, ECPG_SQLSTATE_SQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION, realname ? realname : "<DEFAULT>");
+ ecpg_log("ECPGconnect: socketname %s given for TCP connection on line %d\n", host, lineno);
+ ecpg_raise(lineno, ECPG_CONNECT, ECPG_SQLSTATE_SQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION, realname ? realname : _("<DEFAULT>"));
if (host)
ecpg_free(host);
{
if (strcmp(dbname + offset, "localhost") != 0 && strcmp(dbname + offset, "127.0.0.1") != 0)
{
- ecpg_log("ECPGconnect: non-localhost access via sockets in line %d\n", lineno);
- ecpg_raise(lineno, ECPG_CONNECT, ECPG_SQLSTATE_SQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION, realname ? realname : "<DEFAULT>");
+ 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 : _("<DEFAULT>"));
if (host)
ecpg_free(host);
if (port)
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 ? "for user " : "", user ? user : "");
+ realname ? realname : _("<DEFAULT>"),
+ host ? host : _("<DEFAULT>"),
+ port ? (ecpg_internal_regression_mode ? _("<REGRESSION_PORT>") : port) : _("<DEFAULT>"),
+ options ? _("with options ") : "", options ? options : "",
+ user ? _("for user ") : "", user ? user : "");
connect_string = ecpg_alloc( strlen_or_null(host)
+ strlen_or_null(port)
if (PQstatus(this->connection) == CONNECTION_BAD)
{
const char *errmsg = PQerrorMessage(this->connection);
- const char *db = realname ? realname : "<DEFAULT>";
+ const char *db = realname ? realname : _("<DEFAULT>");
ecpg_log("ECPGconnect: could not open database: %s\n", errmsg);
-/* $PostgreSQL: pgsql/src/interfaces/ecpg/ecpglib/data.c,v 1.40 2007/11/15 21:14:45 momjian Exp $ */
+/* $PostgreSQL: pgsql/src/interfaces/ecpg/ecpglib/data.c,v 1.41 2008/05/16 15:20:03 petere Exp $ */
#define POSTGRES_ECPG_INTERNAL
#include "postgres_fe.h"
else
log_offset = offset;
- ecpg_log("ecpg_get_data line %d: RESULT: %s offset: %ld array: %s\n", lineno, pval ? (binary ? "BINARY" : pval) : "EMPTY", log_offset, isarray ? "Yes" : "No");
+ ecpg_log("ecpg_get_data on line %d: RESULT: %s offset: %ld; array: %s\n", lineno, pval ? (binary ? _("BINARY") : pval) : _("EMPTY"), log_offset, isarray ? _("yes") : _("no"));
/* We will have to decode the value */
else
ecpg_raise(lineno, ECPG_CONVERT_BOOL,
ECPG_SQLSTATE_DATATYPE_MISMATCH,
- "different size");
+ _("different size"));
break;
}
else if (pval[0] == 't' && pval[1] == '\0')
else
ecpg_raise(lineno, ECPG_CONVERT_BOOL,
ECPG_SQLSTATE_DATATYPE_MISMATCH,
- "different size");
+ _("different size"));
break;
}
else if (pval[0] == '\0' && PQgetisnull(results, act_tuple, act_field))
/* did we get an error? */
if (nres == NULL)
{
- ecpg_log("ecpg_get_data line %d: RESULT: %s errno %d\n",
+ ecpg_log("ecpg_get_data on line %d: RESULT %s; errno %d\n",
lineno, pval ? pval : "", errno);
if (INFORMIX_MODE(compat))
/* did we get an error? */
if (ires == NULL)
{
- ecpg_log("ecpg_get_data line %d: RESULT: %s errno %d\n",
+ ecpg_log("ecpg_get_data on line %d: RESULT %s; errno %d\n",
lineno, pval ? pval : "", errno);
if (INFORMIX_MODE(compat))
/* did we get an error? */
if (errno != 0)
{
- ecpg_log("ecpg_get_data line %d: RESULT: %s errno %d\n",
+ ecpg_log("ecpg_get_data on line %d: RESULT %s; errno %d\n",
lineno, pval ? pval : "", errno);
if (INFORMIX_MODE(compat))
/* did we get an error? */
if (errno != 0)
{
- ecpg_log("ecpg_get_data line %d: RESULT: %s errno %d\n",
+ ecpg_log("ecpg_get_data on line %d: RESULT %s; errno %d\n",
lineno, pval ? pval : "", errno);
if (INFORMIX_MODE(compat))
/* dynamic SQL support routines
*
- * $PostgreSQL: pgsql/src/interfaces/ecpg/ecpglib/descriptor.c,v 1.29 2008/01/15 10:31:47 meskes Exp $
+ * $PostgreSQL: pgsql/src/interfaces/ecpg/ecpglib/descriptor.c,v 1.30 2008/05/16 15:20:03 petere Exp $
*/
#define POSTGRES_ECPG_INTERNAL
*count = PQnfields(ECPGresult);
sqlca->sqlerrd[2] = 1;
- ecpg_log("ECPGget_desc_header: found %d attributes.\n", *count);
+ ecpg_log("ECPGget_desc_header: found %d attributes\n", *count);
return true;
}
*/
if (arrsize > 0 && ntuples > arrsize)
{
- ecpg_log("ECPGget_desc line %d: Incorrect number of matches: %d don't fit into array of %d\n",
+ ecpg_log("ECPGget_desc on line %d: incorrect number of matches; %d don't fit into array of %d\n",
lineno, ntuples, arrsize);
ecpg_raise(lineno, ECPG_TOO_MANY_MATCHES, ECPG_SQLSTATE_CARDINALITY_VIOLATION, NULL);
return false;
*/
if (data_var.ind_arrsize > 0 && ntuples > data_var.ind_arrsize)
{
- ecpg_log("ECPGget_desc line %d: Incorrect number of matches (indicator): %d don't fit into array of %d\n",
+ ecpg_log("ECPGget_desc on line %d: incorrect number of matches (indicator); %d don't fit into array of %d\n",
lineno, ntuples, data_var.ind_arrsize);
ecpg_raise(lineno, ECPG_TOO_MANY_MATCHES, ECPG_SQLSTATE_CARDINALITY_VIOLATION, NULL);
return false;
bool
ECPGdescribe(int line, bool input, const char *statement,...)
{
- ecpg_log("ECPGdescribe called on line %d for %s in %s\n", line, (input) ? "input" : "output", statement);
+ ecpg_log("ECPGdescribe called on line %d for %s: %s\n", line, (input) ? _("input") : _("output"), statement);
return false;
}
-/* $PostgreSQL: pgsql/src/interfaces/ecpg/ecpglib/error.c,v 1.19 2007/11/15 21:14:45 momjian Exp $ */
+/* $PostgreSQL: pgsql/src/interfaces/ecpg/ecpglib/error.c,v 1.20 2008/05/16 15:20:03 petere Exp $ */
#define POSTGRES_ECPG_INTERNAL
#include "postgres_fe.h"
{
case ECPG_NOT_FOUND:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- "No data found in line %d.", line);
+ /* translator: this string will be truncated at 149
+ characters expanded. */
+ ecpg_gettext("no data found on line %d"), line);
break;
case ECPG_OUT_OF_MEMORY:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- "Out of memory in line %d.", line);
+ /* translator: this string will be truncated at 149
+ characters expanded. */
+ ecpg_gettext("out of memory on line %d"), line);
break;
case ECPG_UNSUPPORTED:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- "Unsupported type %s in line %d.", str, line);
+ /* translator: this string will be truncated at 149
+ characters expanded. */
+ ecpg_gettext("unsupported type %s on line %d"), str, line);
break;
case ECPG_TOO_MANY_ARGUMENTS:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- "Too many arguments in line %d.", line);
+ /* translator: this string will be truncated at 149
+ characters expanded. */
+ ecpg_gettext("too many arguments on line %d"), line);
break;
case ECPG_TOO_FEW_ARGUMENTS:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- "Too few arguments in line %d.", line);
+ /* translator: this string will be truncated at 149
+ characters expanded. */
+ ecpg_gettext("too few arguments on line %d"), line);
break;
case ECPG_INT_FORMAT:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- "Not correctly formatted int type: %s line %d.", str, line);
+ /* translator: this string will be truncated at 149
+ characters expanded. */
+ ecpg_gettext("not correctly formatted int type \"%s\" on line %d"), str, line);
break;
case ECPG_UINT_FORMAT:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- "Not correctly formatted unsigned type: %s in line %d.", str, line);
+ /* translator: this string will be truncated at 149
+ characters expanded. */
+ ecpg_gettext("not correctly formatted unsigned type \"%s\" on line %d"), str, line);
break;
case ECPG_FLOAT_FORMAT:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- "Not correctly formatted floating-point type: %s in line %d.", str, line);
+ /* translator: this string will be truncated at 149
+ characters expanded. */
+ ecpg_gettext("not correctly formatted floating-point type \"%s\" on line %d"), str, line);
break;
case ECPG_CONVERT_BOOL:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- "Could not convert %s to bool on line %d.", str, line);
+ /* translator: this string will be truncated at 149
+ characters expanded. */
+ ecpg_gettext("could not convert %s to bool on line %d"), str, line);
break;
case ECPG_EMPTY:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- "Empty query in line %d.", line);
+ /* translator: this string will be truncated at 149
+ characters expanded. */
+ ecpg_gettext("empty query on line %d"), line);
break;
case ECPG_MISSING_INDICATOR:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- "NULL value without indicator in line %d.", line);
+ /* translator: this string will be truncated at 149
+ characters expanded. */
+ ecpg_gettext("NULL value without indicator on line %d"), line);
break;
case ECPG_NO_ARRAY:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- "Variable is not an array in line %d.", line);
+ /* translator: this string will be truncated at 149
+ characters expanded. */
+ ecpg_gettext("variable is not an array on line %d"), line);
break;
case ECPG_DATA_NOT_ARRAY:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- "Data read from backend is not an array in line %d.", line);
+ /* translator: this string will be truncated at 149
+ characters expanded. */
+ ecpg_gettext("data read from backend is not an array on line %d"), line);
break;
case ECPG_ARRAY_INSERT:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- "Trying to insert an array of variables in line %d.", line);
+ /* translator: this string will be truncated at 149
+ characters expanded. */
+ ecpg_gettext("trying to insert an array of variables on line %d"), line);
break;
case ECPG_NO_CONN:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- "No such connection %s in line %d.", str, line);
+ /* translator: this string will be truncated at 149
+ characters expanded. */
+ ecpg_gettext("no such connection %s on line %d"), str, line);
break;
case ECPG_NOT_CONN:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- "Not connected to '%s' in line %d.", str, line);
+ /* translator: this string will be truncated at 149
+ characters expanded. */
+ ecpg_gettext("not connected to \"%s\" on line %d"), str, line);
break;
case ECPG_INVALID_STMT:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- "Invalid statement name %s in line %d.", str, line);
+ /* translator: this string will be truncated at 149
+ characters expanded. */
+ ecpg_gettext("invalid statement name %s on line %d"), str, line);
break;
case ECPG_UNKNOWN_DESCRIPTOR:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- "Descriptor %s not found in line %d.", str, line);
+ /* translator: this string will be truncated at 149
+ characters expanded. */
+ ecpg_gettext("descriptor %s not found on line %d"), str, line);
break;
case ECPG_INVALID_DESCRIPTOR_INDEX:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- "Descriptor index out of range in line %d.", line);
+ /* translator: this string will be truncated at 149
+ characters expanded. */
+ ecpg_gettext("descriptor index out of range on line %d"), line);
break;
case ECPG_UNKNOWN_DESCRIPTOR_ITEM:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- "Unknown descriptor item %s in line %d.", str, line);
+ /* translator: this string will be truncated at 149
+ characters expanded. */
+ ecpg_gettext("unknown descriptor item %s on line %d"), str, line);
break;
case ECPG_VAR_NOT_NUMERIC:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- "Variable is not a numeric type in line %d.", line);
+ /* translator: this string will be truncated at 149
+ characters expanded. */
+ ecpg_gettext("variable is not a numeric type on line %d"), line);
break;
case ECPG_VAR_NOT_CHAR:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- "Variable is not a character type in line %d.", line);
+ /* translator: this string will be truncated at 149
+ characters expanded. */
+ ecpg_gettext("variable is not a character type on line %d"), line);
break;
case ECPG_TRANS:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- "Error in transaction processing in line %d.", line);
+ /* translator: this string will be truncated at 149
+ characters expanded. */
+ ecpg_gettext("error in transaction processing on line %d"), line);
break;
case ECPG_CONNECT:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- "Could not connect to database %s in line %d.", str, line);
+ /* translator: this string will be truncated at 149
+ characters expanded. */
+ ecpg_gettext("could not connect to database \"%s\" on line %d"), str, line);
break;
default:
snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- "SQL error #%d in line %d.", code, line);
+ /* translator: this string will be truncated at 149
+ characters expanded. */
+ ecpg_gettext("SQL error %d on line %d"), code, line);
break;
}
sqlca->sqlerrm.sqlerrml = strlen(sqlca->sqlerrm.sqlerrmc);
- ecpg_log("raising sqlcode %d in line %d, '%s'.\n", code, line, sqlca->sqlerrm.sqlerrmc);
+ ecpg_log("raising sqlcode %d on line %d: %s\n", code, line, sqlca->sqlerrm.sqlerrmc);
/* free all memory we have allocated for the user */
ECPGfree_auto_mem();
}
/* copy error message */
- snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
- "'%s' in line %d.", message, line);
+ snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc), "%s on line %d", message, line);
sqlca->sqlerrm.sqlerrml = strlen(sqlca->sqlerrm.sqlerrmc);
/* copy SQLSTATE */
else
sqlca->sqlcode = ECPG_PGSQL;
- ecpg_log("raising sqlstate %.*s (sqlcode: %d) in line %d, '%s'.\n",
+ ecpg_log("raising sqlstate %.*s (sqlcode %d) on line %d: %s\n",
sizeof(sqlca->sqlstate), sqlca->sqlstate, sqlca->sqlcode, line, sqlca->sqlerrm.sqlerrmc);
/* free all memory we have allocated for the user */
{
if (results == NULL)
{
- ecpg_log("ecpg_check_PQresult line %d: error: %s", lineno, PQerrorMessage(connection));
+ ecpg_log("ecpg_check_PQresult on line %d: %s", lineno, PQerrorMessage(connection));
ecpg_raise_backend(lineno, NULL, connection, compat);
return (false);
}
case PGRES_NONFATAL_ERROR:
case PGRES_FATAL_ERROR:
case PGRES_BAD_RESPONSE:
- ecpg_log("ecpg_check_PQresult line %d: Error: %s", lineno, PQresultErrorMessage(results));
+ ecpg_log("ecpg_check_PQresult on line %d: %s", lineno, PQresultErrorMessage(results));
ecpg_raise_backend(lineno, results, connection, compat);
PQclear(results);
return (false);
return (true);
break;
case PGRES_COPY_IN:
- ecpg_log("ecpg_check_PQresult line %d: Got PGRES_COPY_IN ... tossing.\n", lineno);
+ ecpg_log("ecpg_check_PQresult on line %d: COPY IN data transfer in progress\n", lineno);
PQendcopy(connection);
PQclear(results);
return (false);
break;
default:
- ecpg_log("ecpg_check_PQresult line %d: Got something else, postgres error.\n",
+ ecpg_log("ecpg_check_PQresult on line %d: unknown execution status type\n",
lineno);
ecpg_raise_backend(lineno, results, connection, compat);
PQclear(results);
struct sqlca_t *sqlca = ECPGget_sqlca();
sqlca->sqlerrm.sqlerrmc[sqlca->sqlerrm.sqlerrml] = '\0';
- fprintf(stderr, "sql error %s\n", sqlca->sqlerrm.sqlerrmc);
+ fprintf(stderr, _("sql error: %s\n"), sqlca->sqlerrm.sqlerrmc);
}
-/* $PostgreSQL: pgsql/src/interfaces/ecpg/ecpglib/execute.c,v 1.77 2008/03/01 03:26:34 tgl Exp $ */
+/* $PostgreSQL: pgsql/src/interfaces/ecpg/ecpglib/execute.c,v 1.78 2008/05/16 15:20:03 petere Exp $ */
/*
* The aim is to get a simpler inteface to the database routines.
return (ECPG_ARRAY_ERROR);
ecpg_type_infocache_push(&(stmt->connection->cache_head), type, isarray, stmt->lineno);
- ecpg_log("ecpg_is_type_an_array line %d: TYPE database: %d C: %d array: %s\n", stmt->lineno, type, var->type, isarray ? "Yes" : "No");
+ ecpg_log("ecpg_is_type_an_array on line %d: type (%d); C (%d); array (%s)\n", stmt->lineno, type, var->type, isarray ? _("yes") : _("no"));
return isarray;
}
*/
if ((var->arrsize > 0 && ntuples > var->arrsize) || (var->ind_arrsize > 0 && ntuples > var->ind_arrsize))
{
- ecpg_log("ecpg_store_result line %d: Incorrect number of matches: %d don't fit into array of %d\n",
+ ecpg_log("ecpg_store_result on line %d: incorrect number of matches; %d don't fit into array of %d\n",
stmt->lineno, ntuples, var->arrsize);
ecpg_raise(stmt->lineno, INFORMIX_MODE(stmt->compat) ? ECPG_INFORMIX_SUBSELECT_NOT_ONE : ECPG_TOO_MANY_MATCHES, ECPG_SQLSTATE_CARDINALITY_VIOLATION, NULL);
return false;
len = var->offset * ntuples;
break;
}
- ecpg_log("ecpg_store_result: line %d: allocating memory for %d tuples\n", stmt->lineno, ntuples);
+ ecpg_log("ecpg_store_result on line %d: allocating memory for %d tuples\n", stmt->lineno, ntuples);
var->value = (char *) ecpg_alloc(len, stmt->lineno);
if (!var->value)
return false;
for (element = 0; element < var->arrsize; element++)
sprintf(mallocedval + strlen(mallocedval), "%c,", (((int *) var->value)[element]) ? 't' : 'f');
else
- ecpg_raise(lineno, ECPG_CONVERT_BOOL, ECPG_SQLSTATE_DATATYPE_MISMATCH, "different size");
+ ecpg_raise(lineno, ECPG_CONVERT_BOOL, ECPG_SQLSTATE_DATATYPE_MISMATCH, _("different size"));
strcpy(mallocedval + strlen(mallocedval) - 1, "]");
}
else if (var->offset == sizeof(int))
sprintf(mallocedval, "%c", (*((int *) var->value)) ? 't' : 'f');
else
- ecpg_raise(lineno, ECPG_CONVERT_BOOL, ECPG_SQLSTATE_DATATYPE_MISMATCH, "different size");
+ ecpg_raise(lineno, ECPG_CONVERT_BOOL, ECPG_SQLSTATE_DATATYPE_MISMATCH, _("different size"));
}
*tobeinserted_p = mallocedval;
for (n = 0; n < nParams; n++)
{
if (print)
- ecpg_log("free_params line %d: parameter %d = %s\n", lineno, n + 1, paramValues[n] ? paramValues[n] : "null");
+ ecpg_log("free_params on line %d: parameter %d = %s\n", lineno, n + 1, paramValues[n] ? paramValues[n] : _("null"));
ecpg_free((void *) (paramValues[n]));
}
ecpg_free(paramValues);
stmt->connection->committed = false;
}
- ecpg_log("ecpg_execute line %d: QUERY: %s with %d parameter on connection %s \n", stmt->lineno, stmt->command, nParams, stmt->connection->name);
+ ecpg_log("ecpg_execute on line %d: query: %s; with %d parameter(s) on connection %s\n", stmt->lineno, stmt->command, nParams, stmt->connection->name);
if (stmt->statement_type == ECPGst_execute)
{
results = PQexecPrepared(stmt->connection->connection, stmt->name, nParams, paramValues, NULL, NULL, 0);
- ecpg_log("ecpg_execute line %d: using PQexecPrepared for %s\n", stmt->lineno, stmt->command);
+ ecpg_log("ecpg_execute on line %d: using PQexecPrepared for \"%s\"\n", stmt->lineno, stmt->command);
}
else
{
if (nParams == 0)
{
results = PQexec(stmt->connection->connection, stmt->command);
- ecpg_log("ecpg_execute line %d: using PQexec\n", stmt->lineno);
+ ecpg_log("ecpg_execute on line %d: using PQexec\n", stmt->lineno);
}
else
{
results = PQexecParams(stmt->connection->connection, stmt->command, nParams, NULL, paramValues, NULL, NULL, 0);
- ecpg_log("ecpg_execute line %d: using PQexecParams \n", stmt->lineno);
+ ecpg_log("ecpg_execute on line %d: using PQexecParams\n", stmt->lineno);
}
}
case PGRES_TUPLES_OK:
nfields = PQnfields(results);
sqlca->sqlerrd[2] = ntuples = PQntuples(results);
- ecpg_log("ecpg_execute line %d: Correctly got %d tuples with %d fields\n", stmt->lineno, ntuples, nfields);
+ ecpg_log("ecpg_execute on line %d: correctly got %d tuples with %d fields\n", stmt->lineno, ntuples, nfields);
status = true;
if (ntuples < 1)
{
if (ntuples)
- ecpg_log("ecpg_execute line %d: Incorrect number of matches: %d\n",
+ ecpg_log("ecpg_execute on line %d: incorrect number of matches (%d)\n",
stmt->lineno, ntuples);
ecpg_raise(stmt->lineno, ECPG_NOT_FOUND, ECPG_SQLSTATE_NO_DATA, NULL);
status = false;
PQclear(desc->result);
desc->result = results;
clear_result = false;
- ecpg_log("ecpg_execute putting result (%d tuples) into descriptor '%s'\n", PQntuples(results), (const char *) var->pointer);
+ ecpg_log("ecpg_execute on line %d: putting result (%d tuples) into descriptor %s\n",
+ stmt->lineno, PQntuples(results), (const char *) var->pointer);
}
var = var->next;
}
cmdstat = PQcmdStatus(results);
sqlca->sqlerrd[1] = PQoidValue(results);
sqlca->sqlerrd[2] = atol(PQcmdTuples(results));
- ecpg_log("ecpg_execute line %d Ok: %s\n", stmt->lineno, cmdstat);
+ ecpg_log("ecpg_execute on line %d: OK: %s\n", stmt->lineno, cmdstat);
if (stmt->compat != ECPG_COMPAT_INFORMIX_SE &&
!sqlca->sqlerrd[2] &&
(!strncmp(cmdstat, "UPDATE", 6)
char *buffer;
int res;
- ecpg_log("ecpg_execute line %d: Got PGRES_COPY_OUT\n", stmt->lineno);
+ ecpg_log("ecpg_execute on line %d: COPY OUT data transfer in progress\n", stmt->lineno);
while ((res = PQgetCopyData(stmt->connection->connection,
&buffer, 0)) > 0)
{
PQclear(results);
results = PQgetResult(stmt->connection->connection);
if (PQresultStatus(results) == PGRES_COMMAND_OK)
- ecpg_log("ecpg_execute line %d: Got PGRES_COMMAND_OK after PGRES_COPY_OUT\n", stmt->lineno);
+ ecpg_log("ecpg_execute on line %d: got PGRES_COMMAND_OK after PGRES_COPY_OUT\n", stmt->lineno);
else
- ecpg_log("ecpg_execute line %d: Got error after PGRES_COPY_OUT: %s", PQresultErrorMessage(results));
+ ecpg_log("ecpg_execute on line %d: got error after PGRES_COPY_OUT: %s", PQresultErrorMessage(results));
}
break;
}
* execution should never reach this code because it is already
* handled in ECPGcheck_PQresult()
*/
- ecpg_log("ecpg_execute line %d: Got something else, postgres error.\n",
+ ecpg_log("ecpg_execute on line %d: unknown execution status type\n",
stmt->lineno);
ecpg_raise_backend(stmt->lineno, results, stmt->connection->connection, stmt->compat);
status = false;
notify = PQnotifies(stmt->connection->connection);
if (notify)
{
- ecpg_log("ecpg_execute line %d: ASYNC NOTIFY of '%s' from backend pid '%d' received\n",
+ ecpg_log("ecpg_execute on line %d: asynchronous notification of \"%s\" from backend pid %d received\n",
stmt->lineno, notify->relname, notify->be_pid);
PQfreemem(notify);
}
if (con == NULL || con->connection == NULL)
{
free_statement(stmt);
- ecpg_raise(lineno, ECPG_NOT_CONN, ECPG_SQLSTATE_ECPG_INTERNAL_ERROR, (con) ? con->name : "<empty>");
+ ecpg_raise(lineno, ECPG_NOT_CONN, ECPG_SQLSTATE_ECPG_INTERNAL_ERROR, (con) ? con->name : _("<empty>"));
setlocale(LC_NUMERIC, oldlocale);
ecpg_free(oldlocale);
return false;
-/* $PostgreSQL: pgsql/src/interfaces/ecpg/ecpglib/misc.c,v 1.41 2007/11/15 21:14:45 momjian Exp $ */
+/* $PostgreSQL: pgsql/src/interfaces/ecpg/ecpglib/misc.c,v 1.42 2008/05/16 15:20:03 petere Exp $ */
#define POSTGRES_ECPG_INTERNAL
#include "postgres_fe.h"
#include "pgtypes_date.h"
#include "pgtypes_timestamp.h"
#include "pgtypes_interval.h"
+#include "pg_config_paths.h"
#ifdef HAVE_LONG_LONG_INT_64
#ifndef LONG_LONG_MIN
if (con == NULL)
{
ecpg_raise(lineno, ECPG_NO_CONN, ECPG_SQLSTATE_CONNECTION_DOES_NOT_EXIST,
- connection_name ? connection_name : "NULL");
+ connection_name ? connection_name : _("NULL"));
return (false);
}
if (!ecpg_init(con, connection_name, lineno))
return (false);
- ecpg_log("ECPGtrans line %d action = %s connection = %s\n", lineno, transaction, con ? con->name : "(nil)");
+ 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)
va_list ap;
struct sqlca_t *sqlca = ECPGget_sqlca();
+ /* internationalize the error message string */
+ format = ecpg_gettext(format);
+
if (simple_debug)
{
int bufsize = strlen(format) + 100;
#endif /* ENABLE_THREAD_SAFETY */
#endif /* WIN32 */
+
+#ifdef ENABLE_NLS
+
+char *
+ecpg_gettext(const char *msgid)
+{
+ static bool already_bound = false;
+
+ if (!already_bound)
+ {
+ /* dgettext() preserves errno, but bindtextdomain() doesn't */
+#ifdef WIN32
+ int save_errno = GetLastError();
+#else
+ int save_errno = errno;
+#endif
+ const char *ldir;
+
+ already_bound = true;
+ /* No relocatable lookup here because the binary could be anywhere */
+ ldir = getenv("PGLOCALEDIR");
+ if (!ldir)
+ ldir = LOCALEDIR;
+ bindtextdomain("ecpg", ldir);
+#ifdef WIN32
+ SetLastError(save_errno);
+#else
+ errno = save_errno;
+#endif
+ }
+
+ return dgettext("ecpg", msgid);
+}
+
+#endif /* ENABLE_NLS */
-/* $PostgreSQL: pgsql/src/interfaces/ecpg/ecpglib/prepare.c,v 1.28 2008/05/14 15:16:27 momjian Exp $ */
+/* $PostgreSQL: pgsql/src/interfaces/ecpg/ecpglib/prepare.c,v 1.29 2008/05/16 15:20:03 petere Exp $ */
#define POSTGRES_ECPG_INTERNAL
#include "postgres_fe.h"
return false;
}
- ecpg_log("ECPGprepare line %d: NAME: %s QUERY: %s\n", stmt->lineno, name, stmt->command);
+ ecpg_log("ECPGprepare on line %d: name %s; query: \"%s\"\n", stmt->lineno, name, stmt->command);
PQclear(query);
this->prepared = true;
{
bool r = false;
- ecpg_log("ECPGdeallocate line %d: NAME: %s\n", lineno, this->name);
+ ecpg_log("ECPGdeallocate on line %d: name %s\n", lineno, this->name);
/* first deallocate the statement in the backend */
if (this->prepared)
/* if not found - add the statement to the cache */
if (entNo)
{
- ecpg_log("ecpg_auto_prepare line %d: stmt found in cache, entry %d\n", lineno, entNo);
+ ecpg_log("ecpg_auto_prepare on line %d: statement found in cache; entry %d\n", lineno, entNo);
*name = ecpg_strdup(stmtCacheEntries[entNo].stmtID, lineno);
}
else
{
- ecpg_log("ecpg_auto_prepare line %d: stmt not in cache; inserting\n", lineno);
+ ecpg_log("ecpg_auto_prepare on line %d: statement not in cache; inserting\n", lineno);
/* generate a statement ID */
*name = (char *) ecpg_alloc(STMTID_SIZE, lineno);
/*
* this is a small part of c.h since we don't want to leak all postgres
* definitions into ecpg programs
- * $PostgreSQL: pgsql/src/interfaces/ecpg/include/ecpglib.h,v 1.76 2008/03/20 16:29:45 meskes Exp $
+ * $PostgreSQL: pgsql/src/interfaces/ecpg/include/ecpglib.h,v 1.77 2008/05/16 15:20:04 petere Exp $
*/
#ifndef _ECPGLIB_H
#include "sqlca.h"
#include <string.h>
+#ifdef ENABLE_NLS
+extern char *
+ecpg_gettext(const char *msgid)
+__attribute__((format_arg(1)));
+#else
+#define ecpg_gettext(x) (x)
+#endif
+
#ifndef __cplusplus
#ifndef bool
#define bool char
--- /dev/null
+# $PostgreSQL $
+CATALOG_NAME = ecpg
+AVAIL_LANGUAGES =
+GETTEXT_FILES = \
+ compatlib/informix.c \
+ ecpglib/connect.c \
+ ecpglib/data.c \
+ ecpglib/descriptor.c \
+ ecpglib/error.c \
+ ecpglib/execute.c \
+ ecpglib/misc.c \
+ ecpglib/prepare.c \
+ include/ecpglib.h \
+ preproc/descriptor.c \
+ preproc/ecpg.c \
+ preproc/pgc.c \
+ preproc/preproc.c \
+ preproc/type.c \
+ preproc/variable.c
+GETTEXT_TRIGGERS = _ mmerror:3 ecpg_gettext ecpg_log:1
/*
* functions needed for descriptor handling
*
- * $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/descriptor.c,v 1.26 2007/12/21 14:33:20 meskes Exp $
+ * $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/descriptor.c,v 1.27 2008/05/16 15:20:04 petere Exp $
*
* since descriptor might be either a string constant or a string var
* we need to check for a constant if we expect a constant
if (results->value == ECPGd_count)
ECPGnumeric_lvalue(results->variable);
else
- mmerror(PARSE_ERROR, ET_WARNING, "unknown descriptor header item '%d'", results->value);
+ mmerror(PARSE_ERROR, ET_WARNING, "unknown descriptor header item \"%d\"", results->value);
}
drop_assignments();
if (results->value == ECPGd_count)
ECPGnumeric_lvalue(results->variable);
else
- mmerror(PARSE_ERROR, ET_WARNING, "unknown descriptor header item '%d'", results->value);
+ mmerror(PARSE_ERROR, ET_WARNING, "unknown descriptor header item \"%d\"", results->value);
}
drop_assignments();
-/* $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/ecpg.c,v 1.104 2008/02/17 18:14:29 meskes Exp $ */
+/* $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/ecpg.c,v 1.105 2008/05/16 15:20:04 petere Exp $ */
/* New main for ecpg, the PostgreSQL embedded SQL precompiler. */
/* (C) Michael Meskes <meskes@postgresql.org> Feb 5th, 1998 */
static void
help(const char *progname)
{
- printf("%s is the PostgreSQL embedded SQL preprocessor for C programs.\n\n",
+ printf(_("%s is the PostgreSQL embedded SQL preprocessor for C programs.\n\n"),
progname);
- printf("Usage:\n"
- " %s [OPTION]... FILE...\n\n",
+ printf(_("Usage:\n"
+ " %s [OPTION]... FILE...\n\n"),
progname);
- printf("Options:\n");
- printf(" -c automatically generate C code from embedded SQL code;\n"
- " currently this works for EXEC SQL TYPE\n");
- printf(" -C MODE set compatibility mode;\n"
- " MODE can be one of \"INFORMIX\", \"INFORMIX_SE\"\n");
+ printf(_("Options:\n"));
+ printf(_(" -c automatically generate C code from embedded SQL code;\n"
+ " currently this works for EXEC SQL TYPE\n"));
+ printf(_(" -C MODE set compatibility mode;\n"
+ " MODE can be one of \"INFORMIX\", \"INFORMIX_SE\"\n"));
#ifdef YYDEBUG
- printf(" -d generate parser debug output\n");
+ printf(_(" -d generate parser debug output\n"));
#endif
- printf(" -D SYMBOL define SYMBOL\n");
- printf(" -h parse a header file, this option includes option \"-c\"\n");
- printf(" -i parse system include files as well\n");
- printf(" -I DIRECTORY search DIRECTORY for include files\n");
- printf(" -o OUTFILE write result to OUTFILE\n");
- printf(" -r OPTION specify runtime behaviour;\n"
+ printf(_(" -D SYMBOL define SYMBOL\n"));
+ printf(_(" -h parse a header file, this option includes option \"-c\"\n"));
+ printf(_(" -i parse system include files as well\n"));
+ printf(_(" -I DIRECTORY search DIRECTORY for include files\n"));
+ printf(_(" -o OUTFILE write result to OUTFILE\n"));
+ printf(_(" -r OPTION specify runtime behaviour;\n"
" OPTION can be:\n"
" \"no_indicator\"\n"
" \"prepare\"\n"
- " \"questionmarks\"\n");
- printf(" -t turn on autocommit of transactions\n");
- printf(" --help show this help, then exit\n");
- printf(" --regression run in regression testing mode\n");
- printf(" --version output version information, then exit\n");
- printf("\nIf no output file is specified, the name is formed by adding .c to the\n"
- "input file name, after stripping off .pgc if present.\n");
- printf("\nReport bugs to <pgsql-bugs@postgresql.org>.\n");
+ " \"questionmarks\"\n"));
+ printf(_(" -t turn on autocommit of transactions\n"));
+ printf(_(" --help show this help, then exit\n"));
+ printf(_(" --regression run in regression testing mode\n"));
+ printf(_(" --version output version information, then exit\n"));
+ printf(_("\nIf no output file is specified, the name is formed by adding .c to the\n"
+ "input file name, after stripping off .pgc if present.\n"));
+ printf(_("\nReport bugs to <pgsql-bugs@postgresql.org>.\n"));
}
static void
char my_exec_path[MAXPGPATH];
char include_path[MAXPGPATH];
+ set_pglocale_pgservice(argv[0], "ecpg");
+
progname = get_progname(argv[0]);
find_my_exec(argv[0], my_exec_path);
if (yyout == NULL)
{
- fprintf(stderr, "%s: could not open file \"%s\": %s\n",
+ fprintf(stderr, _("%s: could not open file \"%s\": %s\n"),
progname, output_filename, strerror(errno));
output_filename = NULL;
}
}
else
{
- fprintf(stderr, "Try '%s --help' for more information.\n", argv[0]);
+ fprintf(stderr, _("Try \"%s --help\" for more information.\n"), argv[0]);
return ILLEGAL_OPTION;
}
break;
questionmarks = true;
else
{
- fprintf(stderr, "Try '%s --help' for more information.\n", argv[0]);
+ fprintf(stderr, _("Try \"%s --help\" for more information.\n"), argv[0]);
return ILLEGAL_OPTION;
}
break;
#ifdef YYDEBUG
yydebug = 1;
#else
- fprintf(stderr, "%s: parser debug support (-d) not available\n",
+ fprintf(stderr, _("%s: parser debug support (-d) not available\n"),
progname);
#endif
break;
default:
- fprintf(stderr, "Try '%s --help' for more information.\n", argv[0]);
+ fprintf(stderr, _("Try \"%s --help\" for more information.\n"), argv[0]);
return ILLEGAL_OPTION;
}
}
if (verbose)
{
- fprintf(stderr, "%s, the PostgreSQL embedded C preprocessor, version %d.%d.%d\n",
+ fprintf(stderr, _("%s, the PostgreSQL embedded C preprocessor, version %d.%d.%d\n"),
progname, MAJOR_VERSION, MINOR_VERSION, PATCHLEVEL);
- fprintf(stderr, "exec sql include ... search starts here:\n");
+ fprintf(stderr, _("exec sql include ... search starts here:\n"));
for (ip = include_paths; ip != NULL; ip = ip->next)
fprintf(stderr, " %s\n", ip->path);
- fprintf(stderr, "end of search list\n");
+ fprintf(stderr, _("end of search list\n"));
return 0;
}
if (optind >= argc) /* no files specified */
{
- fprintf(stderr, "%s: no input files specified\n", progname);
- fprintf(stderr, "Try '%s --help' for more information.\n", argv[0]);
+ fprintf(stderr, _("%s: no input files specified\n"), progname);
+ fprintf(stderr, _("Try \"%s --help\" for more information.\n"), argv[0]);
return (ILLEGAL_OPTION);
}
else
yyout = fopen(output_filename, PG_BINARY_W);
if (yyout == NULL)
{
- fprintf(stderr, "%s: could not open file \"%s\": %s\n",
+ fprintf(stderr, _("%s: could not open file \"%s\": %s\n"),
progname, output_filename, strerror(errno));
free(output_filename);
free(input_filename);
}
if (yyin == NULL)
- fprintf(stderr, "%s: could not open file \"%s\": %s\n",
+ fprintf(stderr, _("%s: could not open file \"%s\": %s\n"),
progname, argv[fnr], strerror(errno));
else
{
* Does not really make sense to declare a cursor but
* not open it
*/
- snprintf(errortext, sizeof(errortext), "cursor \"%s\" has been declared but not opened\n", ptr->name);
+ snprintf(errortext, sizeof(errortext), _("cursor \"%s\" has been declared but not opened\n"), ptr->name);
mmerror(PARSE_ERROR, ET_WARNING, errortext);
}
ptr = ptr->next;
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/pgc.l,v 1.164 2008/05/09 15:36:31 petere Exp $
+ * $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/pgc.l,v 1.165 2008/05/16 15:20:04 petere Exp $
*
*-------------------------------------------------------------------------
*/
<xc>{op_chars} { ECHO; }
<xc>\*+ { ECHO; }
-<xc><<EOF>> { mmerror(PARSE_ERROR, ET_FATAL, "Unterminated /* comment"); }
+<xc><<EOF>> { mmerror(PARSE_ERROR, ET_FATAL, "unterminated /* comment"); }
<SQL>{xbstart} {
token_start = yytext;
yyless(1);
BEGIN(SQL);
if (literalbuf[strspn(literalbuf, "01") + 1] != '\0')
- mmerror(PARSE_ERROR, ET_ERROR, "invalid bit string input.");
+ mmerror(PARSE_ERROR, ET_ERROR, "invalid bit string input");
yylval.str = mm_strdup(literalbuf);
return BCONST;
}
<xb>{xbinside} { addlit(yytext, yyleng); }
<xh>{quotecontinue} |
<xb>{quotecontinue} { /* ignore */ }
-<xb><<EOF>> { mmerror(PARSE_ERROR, ET_FATAL, "Unterminated bit string"); }
+<xb><<EOF>> { mmerror(PARSE_ERROR, ET_FATAL, "unterminated bit string"); }
<SQL>{xhstart} {
token_start = yytext;
return XCONST;
}
-<xh><<EOF>> { mmerror(PARSE_ERROR, ET_FATAL, "Unterminated hexadecimal integer"); }
+<xh><<EOF>> { mmerror(PARSE_ERROR, ET_FATAL, "unterminated hexadecimal integer"); }
<SQL>{xnstart} {
/* National character.
* Transfer it as-is to the backend.
/* This is only needed for \ just before EOF */
addlitchar(yytext[0]);
}
-<xq,xqc,xe,xn><<EOF>> { mmerror(PARSE_ERROR, ET_FATAL, "Unterminated quoted string"); }
+<xq,xqc,xe,xn><<EOF>> { mmerror(PARSE_ERROR, ET_FATAL, "unterminated quoted string"); }
<SQL>{dolqfailed} {
/* throw back all but the initial "$" */
yyless(1);
}
<xd>{xddouble} { addlitchar('"'); }
<xd>{xdinside} { addlit(yytext, yyleng); }
-<xd,xdc><<EOF>> { mmerror(PARSE_ERROR, ET_FATAL, "Unterminated quoted identifier"); }
+<xd,xdc><<EOF>> { mmerror(PARSE_ERROR, ET_FATAL, "unterminated quoted identifier"); }
<C,SQL>{xdstart} {
state_before = YYSTATE;
BEGIN(xdc);
BEGIN(C);
}
<undef>{other}|\n {
- mmerror(PARSE_ERROR, ET_FATAL, "Missing identifier in 'EXEC SQL UNDEF' command");
+ mmerror(PARSE_ERROR, ET_FATAL, "missing identifier in 'EXEC SQL UNDEF' command");
yyterminate();
}
<C>{exec_sql}{include}{space}* { BEGIN(incl); }
}
<C,xskip>{exec_sql}{elif}{space}* { /* pop stack */
if ( preproc_tos == 0 ) {
- mmerror(PARSE_ERROR, ET_FATAL, "Missing matching 'EXEC SQL IFDEF / EXEC SQL IFNDEF'");
+ mmerror(PARSE_ERROR, ET_FATAL, "missing matching 'EXEC SQL IFDEF / EXEC SQL IFNDEF'");
}
else if ( stacked_if_value[preproc_tos].else_branch )
- mmerror(PARSE_ERROR, ET_FATAL, "Missing 'EXEC SQL ENDIF;'");
+ mmerror(PARSE_ERROR, ET_FATAL, "missing 'EXEC SQL ENDIF;'");
else
preproc_tos--;
if (INFORMIX_MODE)
{
if (preproc_tos == 0)
- mmerror(PARSE_ERROR, ET_FATAL, "Missing matching 'EXEC SQL IFDEF / EXEC SQL IFNDEF'");
+ mmerror(PARSE_ERROR, ET_FATAL, "missing matching 'EXEC SQL IFDEF / EXEC SQL IFNDEF'");
else if (stacked_if_value[preproc_tos].else_branch)
- mmerror(PARSE_ERROR, ET_FATAL, "Missing 'EXEC SQL ENDIF;'");
+ mmerror(PARSE_ERROR, ET_FATAL, "missing 'EXEC SQL ENDIF;'");
else
preproc_tos--;
<C,xskip>{exec_sql}{else}{space}*";" { /* only exec sql endif pops the stack, so take care of duplicated 'else' */
if (stacked_if_value[preproc_tos].else_branch)
- mmerror(PARSE_ERROR, ET_FATAL, "Duplicated 'EXEC SQL ELSE;'");
+ mmerror(PARSE_ERROR, ET_FATAL, "duplicated 'EXEC SQL ELSE;'");
else
{
stacked_if_value[preproc_tos].else_branch = TRUE;
if (INFORMIX_MODE)
{
if (stacked_if_value[preproc_tos].else_branch)
- mmerror(PARSE_ERROR, ET_FATAL, "Duplicated 'EXEC SQL ELSE;'");
+ mmerror(PARSE_ERROR, ET_FATAL, "duplicated 'EXEC SQL ELSE;'");
else
{
stacked_if_value[preproc_tos].else_branch = TRUE;
}
<C,xskip>{exec_sql}{endif}{space}*";" {
if (preproc_tos == 0)
- mmerror(PARSE_ERROR, ET_FATAL, "Unmatched 'EXEC SQL ENDIF;'");
+ mmerror(PARSE_ERROR, ET_FATAL, "unmatched 'EXEC SQL ENDIF;'");
else
preproc_tos--;
if (INFORMIX_MODE)
{
if (preproc_tos == 0)
- mmerror(PARSE_ERROR, ET_FATAL, "Unmatched 'EXEC SQL ENDIF;'");
+ mmerror(PARSE_ERROR, ET_FATAL, "unmatched 'EXEC SQL ENDIF;'");
else
preproc_tos--;
<xcond>{identifier}{space}*";" {
if (preproc_tos >= MAX_NESTED_IF-1)
- mmerror(PARSE_ERROR, ET_FATAL, "Too many nested 'EXEC SQL IFDEF' conditions");
+ mmerror(PARSE_ERROR, ET_FATAL, "too many nested 'EXEC SQL IFDEF' conditions");
else
{
struct _defines *defptr;
}
<xcond>{other}|\n {
- mmerror(PARSE_ERROR, ET_FATAL, "Missing identifier in 'EXEC SQL IFDEF' command");
+ mmerror(PARSE_ERROR, ET_FATAL, "missing identifier in 'EXEC SQL IFDEF' command");
yyterminate();
}
<def_ident>{identifier} {
startlit();
}
<def_ident>{other}|\n {
- mmerror(PARSE_ERROR, ET_FATAL, "Missing identifier in 'EXEC SQL DEFINE' command");
+ mmerror(PARSE_ERROR, ET_FATAL, "missing identifier in 'EXEC SQL DEFINE' command");
yyterminate();
}
<def>{space}*";" {
<incl>{dquote}{xdinside}{dquote}{space}*";"? { parse_include(); }
<incl>[^;\<\>\"]+";" { parse_include(); }
<incl>{other}|\n {
- mmerror(PARSE_ERROR, ET_FATAL, "Incorrect 'EXEC SQL INCLUDE' command");
+ mmerror(PARSE_ERROR, ET_FATAL, "incorrect 'EXEC SQL INCLUDE' command");
yyterminate();
}
if ( preproc_tos > 0 )
{
preproc_tos = 0;
- mmerror(PARSE_ERROR, ET_FATAL, "Missing 'EXEC SQL ENDIF;'");
+ mmerror(PARSE_ERROR, ET_FATAL, "missing 'EXEC SQL ENDIF;'");
}
yyterminate();
}
}
}
-<INITIAL>{other}|\n { mmerror(PARSE_ERROR, ET_FATAL, "Internal error: unreachable state, please inform pgsql-bugs@postgresql.org"); }
+<INITIAL>{other}|\n { mmerror(PARSE_ERROR, ET_FATAL, "Internal error: unreachable state, please report this to <pgsql-bugs@postgresql.org>"); }
%%
void
lex_init(void)
{
if (strlen(ip->path) + strlen(yytext) + 3 > MAXPGPATH)
{
- fprintf(stderr, "Error: Path %s/%s is too long in line %d, skipping.\n", ip->path, yytext, yylineno);
+ fprintf(stderr, _("Error: Path %s/%s is too long on line %d, skipping\n"), ip->path, yytext, yylineno);
continue;
}
snprintf (inc_file, sizeof(inc_file), "%s/%s", ip->path, yytext);
}
}
if (!yyin)
- mmerror(NO_INCLUDE_FILE, ET_FATAL, "Cannot open include file %s in line %d\n", yytext, yylineno);
+ mmerror(NO_INCLUDE_FILE, ET_FATAL, "cannot open include file \"%s\" on line %d\n", yytext, yylineno);
input_filename = mm_strdup(inc_file);
yy_switch_to_buffer(yy_create_buffer(yyin,YY_BUF_SIZE ));
-/* $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/preproc.y,v 1.364 2008/05/12 16:29:04 meskes Exp $ */
+/* $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/preproc.y,v 1.365 2008/05/16 15:20:04 petere Exp $ */
/* Copyright comment */
%{
{
va_list ap;
+ /* internationalize the error message string */
+ error = _(error);
+
fprintf(stderr, "%s:%d: ", input_filename, yylineno);
switch(type)
{
case ET_WARNING:
- fprintf(stderr, "WARNING: ");
+ fprintf(stderr, _("WARNING: "));
break;
case ET_ERROR:
case ET_FATAL:
- fprintf(stderr, "ERROR: ");
+ fprintf(stderr, _("ERROR: "));
break;
}
if (yyout)
fclose(yyout);
if (unlink(output_filename) != 0 && *output_filename != '-')
- fprintf(stderr, "Could not remove output file %s!\n", output_filename);
+ fprintf(stderr, _("could not remove output file \"%s\"\n"), output_filename);
exit(error_code);
}
}
if (ptr == NULL)
{
- mmerror(PARSE_ERROR, ET_ERROR, "trying to access an undeclared cursor %s\n", name);
+ mmerror(PARSE_ERROR, ET_ERROR, "trying to access an undeclared cursor \"%s\"\n", name);
return NULL;
}
if ((type_enum == ECPGt_struct ||
type_enum == ECPGt_union) &&
initializer == 1)
- mmerror(PARSE_ERROR, ET_ERROR, "Initializer not allowed in typedef command");
+ mmerror(PARSE_ERROR, ET_ERROR, "initializer not allowed in typedef command");
else
{
for (ptr = types; ptr != NULL; ptr = ptr->next)
{
if (strcmp(name, ptr->name) == 0)
/* re-definition is a bug */
- mmerror(PARSE_ERROR, ET_ERROR, "Type %s already defined", name);
+ mmerror(PARSE_ERROR, ET_ERROR, "type %s already defined", name);
}
adjust_array(type_enum, &dimension, &length, type_dimension, type_index, array, true);
type_enum != ECPGt_char &&
type_enum != ECPGt_unsigned_char &&
atoi(this->type->type_index) >= 0)
- mmerror(PARSE_ERROR, ET_ERROR, "No multidimensional array support for simple data types");
+ mmerror(PARSE_ERROR, ET_ERROR, "no multidimensional array support for simple data types");
types = this;
}
if (pg_strcasecmp($1+strlen("close "), "database") == 0)
{
if (connection)
- mmerror(PARSE_ERROR, ET_ERROR, "no at option for close database statement.\n");
+ mmerror(PARSE_ERROR, ET_ERROR, "no at option for close database statement\n");
fprintf(yyout, "{ ECPGdisconnect(__LINE__, \"CURRENT\");");
whenever_action(2);
| DeallocateStmt
{
if (connection)
- mmerror(PARSE_ERROR, ET_ERROR, "no at option for deallocate statement.\n");
+ mmerror(PARSE_ERROR, ET_ERROR, "no at option for deallocate statement\n");
output_deallocate_prepare_statement($1);
}
| ECPGConnect
{
if (connection)
- mmerror(PARSE_ERROR, ET_ERROR, "no at option for connect statement.\n");
+ mmerror(PARSE_ERROR, ET_ERROR, "no at option for connect statement\n");
fprintf(yyout, "{ ECPGconnect(__LINE__, %d, %s, %d); ", compat, $1, autocommit);
reset_variables();
| ECPGDeallocateDescr
{
if (connection)
- mmerror(PARSE_ERROR, ET_ERROR, "no at option for deallocate statement.\n");
+ mmerror(PARSE_ERROR, ET_ERROR, "no at option for deallocate statement\n");
fprintf(yyout,"ECPGdeallocate_desc(__LINE__, %s);",$1);
whenever_action(0);
free($1);
| ECPGDisconnect
{
if (connection)
- mmerror(PARSE_ERROR, ET_ERROR, "no at option for disconnect statement.\n");
+ mmerror(PARSE_ERROR, ET_ERROR, "no at option for disconnect statement\n");
fprintf(yyout, "{ ECPGdisconnect(__LINE__, %s);",
$1 ? $1 : "\"CURRENT\"");
| ECPGSetConnection
{
if (connection)
- mmerror(PARSE_ERROR, ET_ERROR, "no at option for set connection statement.\n");
+ mmerror(PARSE_ERROR, ET_ERROR, "no at option for set connection statement\n");
fprintf(yyout, "{ ECPGsetconn(__LINE__, %s);", $1);
whenever_action(2);
| ECPGTypedef
{
if (connection)
- mmerror(PARSE_ERROR, ET_ERROR, "no at option for typedef statement.\n");
+ mmerror(PARSE_ERROR, ET_ERROR, "no at option for typedef statement\n");
fprintf(yyout, "%s", $1);
free($1);
| ECPGVar
{
if (connection)
- mmerror(PARSE_ERROR, ET_ERROR, "no at option for var statement.\n");
+ mmerror(PARSE_ERROR, ET_ERROR, "no at option for var statement\n");
output_simple_statement($1);
}
| ECPGWhenever
{
if (connection)
- mmerror(PARSE_ERROR, ET_ERROR, "no at option for whenever statement.\n");
+ mmerror(PARSE_ERROR, ET_ERROR, "no at option for whenever statement\n");
output_simple_statement($1);
}
copy_file_name copy_delimiter opt_with copy_opt_list
{
if (strcmp($5, "to") == 0 && strcmp($6, "stdin") == 0)
- mmerror(PARSE_ERROR, ET_ERROR, "copy to stdin not possible.\n");
+ mmerror(PARSE_ERROR, ET_ERROR, "copy to stdin not possible\n");
else if (strcmp($5, "from") == 0 && strcmp($6, "stdout") == 0)
- mmerror(PARSE_ERROR, ET_ERROR, "copy from stdout not possible.\n");
+ mmerror(PARSE_ERROR, ET_ERROR, "copy from stdout not possible\n");
else if (strcmp($5, "from") == 0 && strcmp($6, "stdin") == 0)
- mmerror(PARSE_ERROR, ET_WARNING, "copy from stdin not implemented.\n");
+ mmerror(PARSE_ERROR, ET_WARNING, "copy from stdin not implemented\n");
$$ = cat_str(9, make_str("copy"), $2, $3, $4, $5, $6, $7, $8, $9);
}
| COPY select_with_parens TO copy_file_name opt_with copy_opt_list
{
if (strcmp($4, "stdin") == 0)
- mmerror(PARSE_ERROR, ET_ERROR, "copy to stdin not possible.\n");
+ mmerror(PARSE_ERROR, ET_ERROR, "copy to stdin is not possible\n");
$$ = cat_str(6, make_str("copy"), $2, make_str("to"), $4, $5, $6);
}
{ $$ = make_str("match full"); }
| MATCH PARTIAL
{
- mmerror(PARSE_ERROR, ET_WARNING, "Currently unsupported FOREIGN KEY/MATCH PARTIAL will be passed to backend");
+ mmerror(PARSE_ERROR, ET_WARNING, "currently unsupported FOREIGN KEY/MATCH PARTIAL will be passed to backend");
$$ = make_str("match partial");
}
| /*EMPTY*/
opt_grant_grant_option: WITH GRANT OPTION
{
- mmerror(PARSE_ERROR, ET_WARNING, "Currently unsupported GRANT/WITH GRANT OPTION will be passed to backend");
+ mmerror(PARSE_ERROR, ET_WARNING, "currently unsupported GRANT/WITH GRANT OPTION will be passed to backend");
$$ = make_str("with grant option");
}
| /*EMPTY*/ { $$ = EMPTY; }
{
if (strcmp($2, ptr->name) == 0)
/* re-definition is a bug */
- mmerror(PARSE_ERROR, ET_ERROR, "cursor %s already defined", $2);
+ mmerror(PARSE_ERROR, ET_ERROR, "cursor \"%s\" already defined", $2);
}
this = (struct cursor *) mm_alloc(sizeof(struct cursor));
{ $$ = cat2_str(make_str("offset"), $2); }
| LIMIT select_limit_value ',' select_offset_value
{
- mmerror(PARSE_ERROR, ET_WARNING, "No longer supported LIMIT #,# syntax passed to backend.");
+ mmerror(PARSE_ERROR, ET_WARNING, "no longer supported LIMIT #,# syntax passed to backend");
$$ = cat_str(4, make_str("limit"), $2, make_str(","), $4);
}
;
{
/* old style: dbname[@server][:port] */
if (strlen($2) > 0 && *($2) != '@')
- mmerror(PARSE_ERROR, ET_ERROR, "Expected '@', found '%s'", $2);
+ mmerror(PARSE_ERROR, ET_ERROR, "expected \"@\", found \"%s\"", $2);
/* C strings need to be handled differently */
if ($1[0] == '\"')
{
/* new style: <tcp|unix>:postgresql://server[:port][/dbname] */
if (strncmp($1, "unix:postgresql", strlen("unix:postgresql")) != 0 && strncmp($1, "tcp:postgresql", strlen("tcp:postgresql")) != 0)
- mmerror(PARSE_ERROR, ET_ERROR, "only protocols 'tcp' and 'unix' and database type 'postgresql' are supported");
+ mmerror(PARSE_ERROR, ET_ERROR, "only protocols \"tcp\" and \"unix\" and database type \"postgresql\" are supported");
if (strncmp($3, "//", strlen("//")) != 0)
- mmerror(PARSE_ERROR, ET_ERROR, "Expected '://', found '%s'", $3);
+ mmerror(PARSE_ERROR, ET_ERROR, "expected \"://\", found \"%s\"", $3);
if (strncmp($1, "unix", strlen("unix")) == 0 &&
strncmp($3 + strlen("//"), "localhost", strlen("localhost")) != 0 &&
strncmp($3 + strlen("//"), "127.0.0.1", strlen("127.0.0.1")) != 0)
- mmerror(PARSE_ERROR, ET_ERROR, "unix domain sockets only work on 'localhost' but not on '%s'", $3 + strlen("//"));
+ mmerror(PARSE_ERROR, ET_ERROR, "unix domain sockets only work on \"localhost\" but not on \"%s\"", $3 + strlen("//"));
$$ = make3_str(make3_str(make_str("\""), $1, make_str(":")), $3, make3_str(make3_str($4, make_str("/"), $6), $7, make_str("\"")));
}
db_prefix: ident cvariable
{
if (strcmp($2, "postgresql") != 0 && strcmp($2, "postgres") != 0)
- mmerror(PARSE_ERROR, ET_ERROR, "Expected 'postgresql', found '%s'", $2);
+ mmerror(PARSE_ERROR, ET_ERROR, "expected \"postgresql\", found \"%s\"", $2);
if (strcmp($1, "tcp") != 0 && strcmp($1, "unix") != 0)
- mmerror(PARSE_ERROR, ET_ERROR, "Illegal connection type %s", $1);
+ mmerror(PARSE_ERROR, ET_ERROR, "illegal connection type %s", $1);
$$ = make3_str($1, make_str(":"), $2);
}
server: Op server_name
{
if (strcmp($1, "@") != 0 && strcmp($1, "//") != 0)
- mmerror(PARSE_ERROR, ET_ERROR, "Expected '@' or '://', found '%s'", $1);
+ mmerror(PARSE_ERROR, ET_ERROR, "expected \"@\" or \"://\", found \"%s\"", $1);
$$ = make2_str($1, $2);
}
mmerror(PARSE_ERROR, ET_ERROR, "incomplete statement");
if (strcmp($1, "?") != 0)
- mmerror(PARSE_ERROR, ET_ERROR, "unrecognised token '%s'", $1);
+ mmerror(PARSE_ERROR, ET_ERROR, "unrecognized token \"%s\"", $1);
$$ = make2_str(make_str("?"), $2);
}
mmerror(PARSE_ERROR, ET_ERROR, "incomplete statement");
if (strcmp($3, "&") != 0)
- mmerror(PARSE_ERROR, ET_ERROR, "unrecognised token '%s'", $3);
+ mmerror(PARSE_ERROR, ET_ERROR, "unrecognized token \"%s\"", $3);
$$ = cat_str(3, make2_str($1, $2), $3, $4);
}
{
if (strcmp($2, ptr->name) == 0)
/* re-definition is a bug */
- mmerror(PARSE_ERROR, ET_ERROR, "cursor %s already defined", $2);
+ mmerror(PARSE_ERROR, ET_ERROR, "cursor \"%s\" already defined", $2);
}
this = (struct cursor *) mm_alloc(sizeof(struct cursor));
}
else
{
- mmerror(PARSE_ERROR, ET_ERROR, "Only numeric/decimal have precision/scale argument");
+ mmerror(PARSE_ERROR, ET_ERROR, "only numeric/decimal have precision/scale argument");
$$.type_enum = ECPGt_numeric;
$$.type_str = make_str("numeric");
}
| ECPGColLabelCommon ecpg_interval
{
if (strlen($2) != 0 && strcmp ($1, "datetime") != 0 && strcmp ($1, "interval") != 0)
- mmerror (PARSE_ERROR, ET_ERROR, "Interval specification not allowed here ");
+ mmerror (PARSE_ERROR, ET_ERROR, "interval specification not allowed here");
/*
* Check for type names that the SQL grammar treats as
{
struct_member_list[struct_level++] = NULL;
if (struct_level >= STRUCT_DEPTH)
- mmerror(PARSE_ERROR, ET_ERROR, "Too many levels in nested structure/union definition");
+ mmerror(PARSE_ERROR, ET_ERROR, "too many levels in nested structure/union definition");
forward_name = mm_strdup($1.symbol);
}
'{' variable_declarations '}'
{
if (strcmp(su_type.type_str, ptr->name) == 0)
/* re-definition is a bug */
- mmerror(PARSE_ERROR, ET_ERROR, "Type %s already defined", su_type.type_str);
+ mmerror(PARSE_ERROR, ET_ERROR, "type \"%s\" already defined", su_type.type_str);
}
this = (struct typedefs *) mm_alloc(sizeof(struct typedefs));
{
struct_member_list[struct_level++] = NULL;
if (struct_level >= STRUCT_DEPTH)
- mmerror(PARSE_ERROR, ET_ERROR, "Too many levels in nested structure/union definition");
+ mmerror(PARSE_ERROR, ET_ERROR, "too many levels in nested structure/union definition");
}
'{' variable_declarations '}'
{
ECPGDescribe: SQL_DESCRIBE INPUT_P name using_descriptor
{
const char *con = connection ? connection : "NULL";
- mmerror(PARSE_ERROR, ET_WARNING, "using unsupported describe statement.\n");
+ mmerror(PARSE_ERROR, ET_WARNING, "using unsupported describe statement\n");
$$ = (char *) mm_alloc(sizeof("1, ECPGprepared_statement(, \"\", __LINE__)") + strlen(con) + strlen($3));
sprintf($$, "1, ECPGprepared_statement(%s, \"%s\", __LINE__)", con, $3);
}
| SQL_DESCRIBE opt_output name using_descriptor
{
const char *con = connection ? connection : "NULL";
- mmerror(PARSE_ERROR, ET_WARNING, "using unsupported describe statement.\n");
+ mmerror(PARSE_ERROR, ET_WARNING, "using unsupported describe statement\n");
$$ = (char *) mm_alloc(sizeof("0, ECPGprepared_statement(, \"\", __LINE__)") + strlen(con) + strlen($3));
sprintf($$, "0, ECPGprepared_statement(%s, \"%s\", __LINE__)", con, $3);
}
| SQL_DESCRIBE opt_output name into_descriptor
{
const char *con = connection ? connection : "NULL";
- mmerror(PARSE_ERROR, ET_WARNING, "using unsupported describe statement.\n");
+ mmerror(PARSE_ERROR, ET_WARNING, "using unsupported describe statement\n");
$$ = (char *) mm_alloc(sizeof("0, ECPGprepared_statement(, \"\", __LINE__)") + strlen(con) + strlen($3));
sprintf($$, "0, ECPGprepared_statement(%s, \"%s\", __LINE__)", con, $3);
}
if (($5.type_enum == ECPGt_struct ||
$5.type_enum == ECPGt_union) &&
initializer == 1)
- mmerror(PARSE_ERROR, ET_ERROR, "Initializer not allowed in EXEC SQL VAR command");
+ mmerror(PARSE_ERROR, ET_ERROR, "initializer not allowed in EXEC SQL VAR command");
else
{
adjust_array($5.type_enum, &dimension, &length, $5.type_dimension, $5.type_index, *$7?1:0, false);
default:
if (atoi(length) >= 0)
- mmerror(PARSE_ERROR, ET_ERROR, "No multidimensional array support for simple data types");
+ mmerror(PARSE_ERROR, ET_ERROR, "no multidimensional array support for simple data types");
if (atoi(dimension) < 0)
type = ECPGmake_simple_type($5.type_enum, make_str("1"), 0);
{
case '[':
if (brace)
- mmerror(PARSE_ERROR, ET_FATAL, "No multidimensional array support for simple data types");
+ mmerror(PARSE_ERROR, ET_FATAL, "no multidimensional array support for simple data types");
brace_open++;
break;
case ']':
{
char buf[1024];
- snprintf(buf,sizeof buf,"%s at or near \"%s\"", error, token_start ? token_start : yytext);
+ snprintf(buf,sizeof buf, _("%s at or near \"%s\""), error, token_start ? token_start : yytext);
buf[sizeof(buf)-1]=0;
mmerror(PARSE_ERROR, ET_ERROR, buf);
}
-/* $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/type.c,v 1.78 2008/03/02 10:54:11 meskes Exp $ */
+/* $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/type.c,v 1.79 2008/05/16 15:20:04 petere Exp $ */
#include "postgres_fe.h"
void *ptr = malloc(size);
if (ptr == NULL)
- mmerror(OUT_OF_MEMORY, ET_FATAL, "Out of memory\n");
+ mmerror(OUT_OF_MEMORY, ET_FATAL, "out of memory\n");
return ptr;
}
char *new = strdup(string);
if (new == NULL)
- mmerror(OUT_OF_MEMORY, ET_FATAL, "Out of memory\n");
+ mmerror(OUT_OF_MEMORY, ET_FATAL, "out of memory\n");
return new;
}
{
case ECPGt_array:
if (indicator_set && ind_type->type != ECPGt_array)
- mmerror(INDICATOR_NOT_ARRAY, ET_FATAL, "Indicator for array/pointer has to be array/pointer.\n");
+ mmerror(INDICATOR_NOT_ARRAY, ET_FATAL, "indicator for array/pointer has to be array/pointer\n");
switch (type->u.element->type)
{
case ECPGt_array:
- mmerror(PARSE_ERROR, ET_ERROR, "No nested arrays allowed (except strings)"); /* array of array */
+ mmerror(PARSE_ERROR, ET_ERROR, "no nested arrays allowed (except strings)"); /* array of array */
break;
case ECPGt_struct:
case ECPGt_union:
break;
default:
if (!IS_SIMPLE_TYPE(type->u.element->type))
- base_yyerror("Internal error: unknown datatype, please inform pgsql-bugs@postgresql.org");
+ base_yyerror("internal error: unknown datatype, please report this to <pgsql-bugs@postgresql.org>");
ECPGdump_a_simple(o, name,
type->u.element->type,
break;
case ECPGt_struct:
if (indicator_set && ind_type->type != ECPGt_struct)
- mmerror(INDICATOR_NOT_STRUCT, ET_FATAL, "Indicator for struct has to be struct.\n");
+ mmerror(INDICATOR_NOT_STRUCT, ET_FATAL, "indicator for struct has to be struct\n");
ECPGdump_a_struct(o, name, ind_name, make_str("1"), type, ind_type, NULL, prefix, ind_prefix);
break;
case ECPGt_union: /* cannot dump a complete union */
- base_yyerror("Type of union has to be specified");
+ base_yyerror("type of union has to be specified");
break;
case ECPGt_char_variable:
if (indicator_set && (ind_type->type == ECPGt_struct || ind_type->type == ECPGt_array))
- mmerror(INDICATOR_NOT_SIMPLE, ET_FATAL, "Indicator for simple datatype has to be simple.\n");
+ mmerror(INDICATOR_NOT_SIMPLE, ET_FATAL, "indicator for simple datatype has to be simple\n");
ECPGdump_a_simple(o, name, type->type, make_str("1"), (arr_str_siz && strcmp(arr_str_siz, "0") != 0) ? arr_str_siz : make_str("1"), struct_sizeof, prefix, 0);
if (ind_type != NULL)
break;
case ECPGt_descriptor:
if (indicator_set && (ind_type->type == ECPGt_struct || ind_type->type == ECPGt_array))
- mmerror(INDICATOR_NOT_SIMPLE, ET_FATAL, "Indicator for simple datatype has to be simple.\n");
+ mmerror(INDICATOR_NOT_SIMPLE, ET_FATAL, "indicator for simple datatype has to be simple\n");
ECPGdump_a_simple(o, name, type->type, NULL, make_str("-1"), NULL, prefix, 0);
if (ind_type != NULL)
break;
default:
if (indicator_set && (ind_type->type == ECPGt_struct || ind_type->type == ECPGt_array))
- mmerror(INDICATOR_NOT_SIMPLE, ET_FATAL, "Indicator for simple datatype has to be simple.\n");
+ mmerror(INDICATOR_NOT_SIMPLE, ET_FATAL, "indicator for simple datatype has to be simple\n");
ECPGdump_a_simple(o, name, type->type, type->size, (arr_str_siz && strcmp(arr_str_siz, "0") != 0) ? arr_str_siz : make_str("-1"), struct_sizeof, prefix, type->lineno);
if (ind_type != NULL)
switch (type->u.element->type)
{
case ECPGt_array:
- base_yyerror("internal error, found multidimensional array\n");
+ base_yyerror("internal error: found multidimensional array\n");
break;
case ECPGt_struct:
case ECPGt_union:
break;
default:
if (!IS_SIMPLE_TYPE(type->u.element->type))
- base_yyerror("Internal error: unknown datatype, please inform pgsql-bugs@postgresql.org");
+ base_yyerror("internal error: unknown datatype, please report this to <pgsql-bugs@postgresql.org>");
free(type->u.element);
}
-/* $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/variable.c,v 1.44 2008/02/07 11:09:13 meskes Exp $ */
+/* $PostgreSQL: pgsql/src/interfaces/ecpg/preproc/variable.c,v 1.45 2008/05/16 15:20:04 petere Exp $ */
#include "postgres_fe.h"
*next = '\0';
p = find_simple(name);
if (p == NULL)
- mmerror(PARSE_ERROR, ET_FATAL, "The variable %s is not declared", name);
+ mmerror(PARSE_ERROR, ET_FATAL, "variable %s is not declared", name);
*next = c;
switch (p->type->u.element->type)
p = find_simple(name);
if (p == NULL)
- mmerror(PARSE_ERROR, ET_FATAL, "The variable %s is not declared", name);
+ mmerror(PARSE_ERROR, ET_FATAL, "variable %s is not declared", name);
return (p);
}
for (this = types; this && strcmp(this->name, name); this = this->next);
if (!this)
- mmerror(PARSE_ERROR, ET_FATAL, "invalid datatype '%s'", name);
+ mmerror(PARSE_ERROR, ET_FATAL, "invalid datatype \"%s\"", name);
return (this);
}
if (atoi(type_index) >= 0)
{
if (atoi(*length) >= 0)
- mmerror(PARSE_ERROR, ET_FATAL, "No multidimensional array support");
+ mmerror(PARSE_ERROR, ET_FATAL, "no multidimensional array support");
*length = type_index;
}
if (atoi(type_dimension) >= 0)
{
if (atoi(*dimension) >= 0 && atoi(*length) >= 0)
- mmerror(PARSE_ERROR, ET_FATAL, "No multidimensional array support");
+ mmerror(PARSE_ERROR, ET_FATAL, "no multidimensional array support");
if (atoi(*dimension) >= 0)
*length = *dimension;
}
if (pointer_len > 2)
- mmerror(PARSE_ERROR, ET_FATAL, "No multilevel (more than 2) pointer supported %d", pointer_len);
+ mmerror(PARSE_ERROR, ET_FATAL, "no multilevel (more than 2) pointer supported %d", pointer_len);
if (pointer_len > 1 && type_enum != ECPGt_char && type_enum != ECPGt_unsigned_char)
- mmerror(PARSE_ERROR, ET_FATAL, "No pointer to pointer supported for this type");
+ mmerror(PARSE_ERROR, ET_FATAL, "no pointer to pointer supported for this type");
if (pointer_len > 1 && (atoi(*length) >= 0 || atoi(*dimension) >= 0))
- mmerror(PARSE_ERROR, ET_FATAL, "No multidimensional array support");
+ mmerror(PARSE_ERROR, ET_FATAL, "no multidimensional array support");
if (atoi(*length) >= 0 && atoi(*dimension) >= 0 && pointer_len)
- mmerror(PARSE_ERROR, ET_FATAL, "No multidimensional array support");
+ mmerror(PARSE_ERROR, ET_FATAL, "no multidimensional array support");
switch (type_enum)
{
}
if (atoi(*length) >= 0)
- mmerror(PARSE_ERROR, ET_FATAL, "No multidimensional array support for structures");
+ mmerror(PARSE_ERROR, ET_FATAL, "no multidimensional array support for structures");
break;
case ECPGt_varchar:
}
if (atoi(*length) >= 0)
- mmerror(PARSE_ERROR, ET_FATAL, "No multidimensional array support for simple data types");
+ mmerror(PARSE_ERROR, ET_FATAL, "no multidimensional array support for simple data types");
break;
}
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 31: QUERY: create table test ( id int , c char ( 10 ) , s smallint , i int , b bool , f float , l bigint , dbl double precision , dec decimal , dat date , tmp timestamptz ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 31: query: create table test ( id int , c char ( 10 ) , s smallint , i int , b bool , f float , l bigint , dbl double precision , dec decimal , dat date , tmp timestamptz ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 31: using PQexec
+[NO_PID]: ecpg_execute on line 31: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 31 Ok: CREATE TABLE
+[NO_PID]: ecpg_execute on line 31: OK: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 34 action = commit connection = regress1
+[NO_PID]: ECPGtrans on line 34: action "commit"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 36: QUERY: insert into test ( id , c , s , i , b , f , l , dbl ) values ( 1 , $1 , $2 , $3 , $4 , $5 , $6 , $7 ) with 7 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 36: query: insert into test ( id , c , s , i , b , f , l , dbl ) values ( 1 , $1 , $2 , $3 , $4 , $5 , $6 , $7 ) ; with 7 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 36: using PQexecParams
+[NO_PID]: ecpg_execute on line 36: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 36: parameter 1 = abc
+[NO_PID]: free_params on line 36: parameter 1 = abc
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 36: parameter 2 = 17
+[NO_PID]: free_params on line 36: parameter 2 = 17
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 36: parameter 3 = -74874
+[NO_PID]: free_params on line 36: parameter 3 = -74874
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 36: parameter 4 = t
+[NO_PID]: free_params on line 36: parameter 4 = t
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 36: parameter 5 = 3.710000038147
+[NO_PID]: free_params on line 36: parameter 5 = 3.710000038147
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 36: parameter 6 = 487444
+[NO_PID]: free_params on line 36: parameter 6 = 487444
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 36: parameter 7 = 404.404
+[NO_PID]: free_params on line 36: parameter 7 = 404.404
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 36 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 36: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 39 action = commit connection = regress1
+[NO_PID]: ECPGtrans on line 39: action "commit"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 52: QUERY: insert into test ( id , c , s , i , b , f , l , dbl , dec , dat , tmp ) values ( 2 , $1 , $2 , $3 , $4 , $5 , $6 , $7 , $8 , $9 , $10 ) with 10 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 52: query: insert into test ( id , c , s , i , b , f , l , dbl , dec , dat , tmp ) values ( 2 , $1 , $2 , $3 , $4 , $5 , $6 , $7 , $8 , $9 , $10 ) ; with 10 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 52: using PQexecParams
+[NO_PID]: ecpg_execute on line 52: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 52: parameter 1 = null
+[NO_PID]: free_params on line 52: parameter 1 = null
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 52: parameter 2 = null
+[NO_PID]: free_params on line 52: parameter 2 = null
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 52: parameter 3 = null
+[NO_PID]: free_params on line 52: parameter 3 = null
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 52: parameter 4 = t
+[NO_PID]: free_params on line 52: parameter 4 = t
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 52: parameter 5 = null
+[NO_PID]: free_params on line 52: parameter 5 = null
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 52: parameter 6 = null
+[NO_PID]: free_params on line 52: parameter 6 = null
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 52: parameter 7 = null
+[NO_PID]: free_params on line 52: parameter 7 = null
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 52: parameter 8 = null
+[NO_PID]: free_params on line 52: parameter 8 = null
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 52: parameter 9 = null
+[NO_PID]: free_params on line 52: parameter 9 = null
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 52: parameter 10 = null
+[NO_PID]: free_params on line 52: parameter 10 = null
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 52 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 52: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 55 action = commit connection = regress1
+[NO_PID]: ECPGtrans on line 55: action "commit"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 59: QUERY: select c , s , i , b , f , l , dbl , dec , dat , tmp from test where id = 1 with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 59: query: select c , s , i , b , f , l , dbl , dec , dat , tmp from test where id = 1 ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 59: using PQexec
+[NO_PID]: ecpg_execute on line 59: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 59: Correctly got 1 tuples with 10 fields
+[NO_PID]: ecpg_execute on line 59: correctly got 1 tuples with 10 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 59: RESULT: abc offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 59: RESULT: abc offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 59: RESULT: 17 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 59: RESULT: 17 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 59: RESULT: -74874 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 59: RESULT: -74874 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 59: RESULT: t offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 59: RESULT: t offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 59: RESULT: 3.710000038147 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 59: RESULT: 3.710000038147 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 59: RESULT: 487444 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 59: RESULT: 487444 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 59: RESULT: 404.404 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 59: RESULT: 404.404 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 59: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 59: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 59: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 59: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 59: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 59: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 76: QUERY: select c , s , i , b , f , l , dbl , dec , dat , tmp from test where id = 2 with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 76: query: select c , s , i , b , f , l , dbl , dec , dat , tmp from test where id = 2 ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 76: using PQexec
+[NO_PID]: ecpg_execute on line 76: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 76: Correctly got 1 tuples with 10 fields
+[NO_PID]: ecpg_execute on line 76: correctly got 1 tuples with 10 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 76: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 76: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 76: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 76: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 76: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 76: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 76: RESULT: t offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 76: RESULT: t offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 76: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 76: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 76: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 76: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 76: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 76: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 76: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 76: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 76: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 76: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 76: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 76: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 91: QUERY: drop table test with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 91: query: drop table test ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 91: using PQexec
+[NO_PID]: ecpg_execute on line 91: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 91 Ok: DROP TABLE
+[NO_PID]: ecpg_execute on line 91: OK: DROP TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 92 action = commit connection = regress1
+[NO_PID]: ECPGtrans on line 92: action "commit"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection regress1 closed.
+[NO_PID]: ecpg_finish: connection regress1 closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 23: QUERY: create table test ( i int primary key , j int ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 23: query: create table test ( i int primary key , j int ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 23: using PQexec
+[NO_PID]: ecpg_execute on line 23: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 23 Ok: CREATE TABLE
+[NO_PID]: ecpg_execute on line 23: OK: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 27: QUERY: insert into test ( i , j ) values ( 7 , $1 ) with 1 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 27: query: insert into test ( i , j ) values ( 7 , $1 ) ; with 1 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 27: using PQexecParams
+[NO_PID]: ecpg_execute on line 27: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 27: parameter 1 = 0
+[NO_PID]: free_params on line 27: parameter 1 = 0
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 27 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 27: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 28 action = commit connection = regress1
+[NO_PID]: ECPGtrans on line 28: action "commit"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 31: QUERY: insert into test ( i , j ) values ( 7 , 12 ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 31: query: insert into test ( i , j ) values ( 7 , 12 ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 31: using PQexec
+[NO_PID]: ecpg_execute on line 31: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_check_PQresult line 31: Error: ERROR: duplicate key value violates unique constraint "test_pkey"
+[NO_PID]: ecpg_check_PQresult on line 31: ERROR: duplicate key value violates unique constraint "test_pkey"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: raising sqlstate 23505 (sqlcode: -239) in line 31, ''duplicate key value violates unique constraint "test_pkey"' in line 31.'.
+[NO_PID]: raising sqlstate 23505 (sqlcode -239) on line 31: duplicate key value violates unique constraint "test_pkey" on line 31
[NO_PID]: sqlca: code: -239, state: 23505
-[NO_PID]: ECPGtrans line 33 action = rollback connection = regress1
+[NO_PID]: ECPGtrans on line 33: action "rollback"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35: QUERY: insert into test ( i , j ) values ( $1 , 1 ) with 1 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 35: query: insert into test ( i , j ) values ( $1 , 1 ) ; with 1 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35: using PQexecParams
+[NO_PID]: ecpg_execute on line 35: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 35: parameter 1 = 14
+[NO_PID]: free_params on line 35: parameter 1 = 14
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 35: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 36 action = commit connection = regress1
+[NO_PID]: ECPGtrans on line 36: action "commit"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 39: QUERY: select i from test where j = ( select j from test ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 39: query: select i from test where j = ( select j from test ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 39: using PQexec
+[NO_PID]: ecpg_execute on line 39: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_check_PQresult line 39: Error: ERROR: more than one row returned by a subquery used as an expression
+[NO_PID]: ecpg_check_PQresult on line 39: ERROR: more than one row returned by a subquery used as an expression
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: raising sqlstate 21000 (sqlcode: -284) in line 39, ''more than one row returned by a subquery used as an expression' in line 39.'.
+[NO_PID]: raising sqlstate 21000 (sqlcode -284) on line 39: more than one row returned by a subquery used as an expression on line 39
[NO_PID]: sqlca: code: -284, state: 21000
-[NO_PID]: ECPGtrans line 40 action = rollback connection = regress1
+[NO_PID]: ECPGtrans on line 40: action "rollback"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 43: QUERY: select i from test where j = ( select j from test order by i limit 1 ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 43: query: select i from test where j = ( select j from test order by i limit 1 ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 43: using PQexec
+[NO_PID]: ecpg_execute on line 43: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 43: Correctly got 1 tuples with 1 fields
+[NO_PID]: ecpg_execute on line 43: correctly got 1 tuples with 1 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 92: QUERY: declare c cursor for select * from test where i <= $1 with 1 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 92: query: declare c cursor for select * from test where i <= $1 ; with 1 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 92: using PQexecParams
+[NO_PID]: ecpg_execute on line 92: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 92: parameter 1 = 14
+[NO_PID]: free_params on line 92: parameter 1 = 14
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 92 Ok: DECLARE CURSOR
+[NO_PID]: ecpg_execute on line 92: OK: DECLARE CURSOR
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 54: QUERY: fetch forward from c with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 54: query: fetch forward from c; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 54: using PQexec
+[NO_PID]: ecpg_execute on line 54: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 54: Correctly got 1 tuples with 2 fields
+[NO_PID]: ecpg_execute on line 54: correctly got 1 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 54: RESULT: 7 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 54: RESULT: 7 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 54: RESULT: 0 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 54: RESULT: 0 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 54: QUERY: fetch forward from c with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 54: query: fetch forward from c; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 54: using PQexec
+[NO_PID]: ecpg_execute on line 54: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 54: Correctly got 1 tuples with 2 fields
+[NO_PID]: ecpg_execute on line 54: correctly got 1 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 54: RESULT: 14 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 54: RESULT: 14 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 54: RESULT: 1 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 54: RESULT: 1 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 54: QUERY: fetch forward from c with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 54: query: fetch forward from c; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 54: using PQexec
+[NO_PID]: ecpg_execute on line 54: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 54: Correctly got 0 tuples with 2 fields
+[NO_PID]: ecpg_execute on line 54: correctly got 0 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: raising sqlcode 100 in line 54, 'No data found in line 54.'.
+[NO_PID]: raising sqlcode 100 on line 54: no data found on line 54
[NO_PID]: sqlca: code: 100, state: 02000
-[NO_PID]: ecpg_execute line 72: QUERY: delete from test where i = $1 :: decimal with 1 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 72: query: delete from test where i = $1 :: decimal ; with 1 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 72: using PQexecParams
+[NO_PID]: ecpg_execute on line 72: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 72: parameter 1 = 21.0
+[NO_PID]: free_params on line 72: parameter 1 = 21.0
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 72 Ok: DELETE 0
+[NO_PID]: ecpg_execute on line 72: OK: DELETE 0
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: raising sqlcode 100 in line 72, 'No data found in line 72.'.
+[NO_PID]: raising sqlcode 100 on line 72: no data found on line 72
[NO_PID]: sqlca: code: 100, state: 02000
-[NO_PID]: ecpg_execute line 75: QUERY: select 1 from test where i = 14 with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 75: query: select 1 from test where i = 14 ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 75: using PQexec
+[NO_PID]: ecpg_execute on line 75: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 75: Correctly got 1 tuples with 1 fields
+[NO_PID]: ecpg_execute on line 75: correctly got 1 tuples with 1 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 78: QUERY: select 1 from test where i = 147 with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 78: query: select 1 from test where i = 147 ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 78: using PQexec
+[NO_PID]: ecpg_execute on line 78: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 78: Correctly got 0 tuples with 1 fields
+[NO_PID]: ecpg_execute on line 78: correctly got 0 tuples with 1 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: raising sqlcode 100 in line 78, 'No data found in line 78.'.
+[NO_PID]: raising sqlcode 100 on line 78: no data found on line 78
[NO_PID]: sqlca: code: 100, state: 02000
-[NO_PID]: ECPGtrans line 81 action = commit connection = regress1
+[NO_PID]: ECPGtrans on line 81: action "commit"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 82: QUERY: drop table test with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 82: query: drop table test ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 82: using PQexec
+[NO_PID]: ecpg_execute on line 82: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 82 Ok: DROP TABLE
+[NO_PID]: ecpg_execute on line 82: OK: DROP TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 83 action = commit connection = regress1
+[NO_PID]: ECPGtrans on line 83: action "commit"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection regress1 closed.
+[NO_PID]: ecpg_finish: connection regress1 closed
[NO_PID]: sqlca: code: 0, state: 00000
-doSQLprint: Error: 'duplicate key value violates unique constraint "test_pkey"' in line 31.
-INSERT: -239='duplicate key value violates unique constraint "test_pkey"' in line 31.
-doSQLprint: Error: 'more than one row returned by a subquery used as an expression' in line 39.
+doSQLprint: Error: duplicate key value violates unique constraint "test_pkey" on line 31
+INSERT: -239=duplicate key value violates unique constraint "test_pkey" on line 31
+doSQLprint: Error: more than one row returned by a subquery used as an expression on line 39
SELECT: 0=
7 0
14 1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 66: QUERY: set DateStyle to 'DMY' with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 66: query: set DateStyle to 'DMY'; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 66: using PQexec
+[NO_PID]: ecpg_execute on line 66: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 66 Ok: SET
+[NO_PID]: ecpg_execute on line 66: OK: SET
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 68: QUERY: create table history ( customerid integer , timestamp timestamp without time zone , action_taken char ( 5 ) , narrative varchar ( 100 ) ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 68: query: create table history ( customerid integer , timestamp timestamp without time zone , action_taken char ( 5 ) , narrative varchar ( 100 ) ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 68: using PQexec
+[NO_PID]: ecpg_execute on line 68: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 68 Ok: CREATE TABLE
+[NO_PID]: ecpg_execute on line 68: OK: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 71: QUERY: insert into history ( customerid , timestamp , action_taken , narrative ) values ( 1 , '2003-05-07 13:28:34 CEST' , 'test' , 'test' ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 71: query: insert into history ( customerid , timestamp , action_taken , narrative ) values ( 1 , '2003-05-07 13:28:34 CEST' , 'test' , 'test' ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 71: using PQexec
+[NO_PID]: ecpg_execute on line 71: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 71 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 71: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 76: QUERY: select max ( timestamp ) from history with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 76: query: select max ( timestamp ) from history ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 76: using PQexec
+[NO_PID]: ecpg_execute on line 76: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 76: Correctly got 1 tuples with 1 fields
+[NO_PID]: ecpg_execute on line 76: correctly got 1 tuples with 1 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 76: RESULT: Wed 07 May 13:28:34 2003 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 76: RESULT: Wed 07 May 13:28:34 2003 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 81: QUERY: select customerid , timestamp from history where timestamp = $1 limit 1 with 1 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 81: query: select customerid , timestamp from history where timestamp = $1 limit 1 ; with 1 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 81: using PQexecParams
+[NO_PID]: ecpg_execute on line 81: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 81: parameter 1 = 2003-05-07 13:28:34
+[NO_PID]: free_params on line 81: parameter 1 = 2003-05-07 13:28:34
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 81: Correctly got 1 tuples with 2 fields
+[NO_PID]: ecpg_execute on line 81: correctly got 1 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 81: RESULT: 1 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 81: RESULT: 1 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 81: RESULT: Wed 07 May 13:28:34 2003 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 81: RESULT: Wed 07 May 13:28:34 2003 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 95: QUERY: insert into history ( customerid , timestamp , action_taken , narrative ) values ( $1 , $2 , 'test' , 'test' ) with 2 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 95: query: insert into history ( customerid , timestamp , action_taken , narrative ) values ( $1 , $2 , 'test' , 'test' ) ; with 2 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 95: using PQexecParams
+[NO_PID]: ecpg_execute on line 95: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 95: parameter 1 = 2
+[NO_PID]: free_params on line 95: parameter 1 = 2
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 95: parameter 2 = 2003-05-08 15:53:39
+[NO_PID]: free_params on line 95: parameter 2 = 2003-05-08 15:53:39
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 95 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 95: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 100 action = commit connection = regress1
+[NO_PID]: ECPGtrans on line 100: action "commit"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 102: QUERY: drop table history with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 102: query: drop table history ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 102: using PQexec
+[NO_PID]: ecpg_execute on line 102: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 102 Ok: DROP TABLE
+[NO_PID]: ecpg_execute on line 102: OK: DROP TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 105 action = commit connection = regress1
+[NO_PID]: ECPGtrans on line 105: action "commit"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection regress1 closed.
+[NO_PID]: ecpg_finish: connection regress1 closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 28: QUERY: select current_database () with 0 parameter on connection second
+[NO_PID]: ecpg_execute on line 28: query: select current_database () ; with 0 parameter(s) on connection second
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 28: using PQexec
+[NO_PID]: ecpg_execute on line 28: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 28: Correctly got 1 tuples with 1 fields
+[NO_PID]: ecpg_execute on line 28: correctly got 1 tuples with 1 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 28: RESULT: regress1 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 28: RESULT: regress1 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 29: QUERY: select current_database () with 0 parameter on connection first
+[NO_PID]: ecpg_execute on line 29: query: select current_database () ; with 0 parameter(s) on connection first
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 29: using PQexec
+[NO_PID]: ecpg_execute on line 29: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 29: Correctly got 1 tuples with 1 fields
+[NO_PID]: ecpg_execute on line 29: correctly got 1 tuples with 1 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 29: RESULT: connectdb offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 29: RESULT: connectdb offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 30: QUERY: select current_database () with 0 parameter on connection second
+[NO_PID]: ecpg_execute on line 30: query: select current_database () ; with 0 parameter(s) on connection second
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 30: using PQexec
+[NO_PID]: ecpg_execute on line 30: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 30: Correctly got 1 tuples with 1 fields
+[NO_PID]: ecpg_execute on line 30: correctly got 1 tuples with 1 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 30: RESULT: regress1 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 30: RESULT: regress1 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 33: QUERY: select current_database () with 0 parameter on connection first
+[NO_PID]: ecpg_execute on line 33: query: select current_database () ; with 0 parameter(s) on connection first
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 33: using PQexec
+[NO_PID]: ecpg_execute on line 33: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 33: Correctly got 1 tuples with 1 fields
+[NO_PID]: ecpg_execute on line 33: correctly got 1 tuples with 1 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 33: RESULT: connectdb offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 33: RESULT: connectdb offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection first closed.
+[NO_PID]: ecpg_finish: connection first closed
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 37: QUERY: select current_database () with 0 parameter on connection second
+[NO_PID]: ecpg_execute on line 37: query: select current_database () ; with 0 parameter(s) on connection second
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 37: using PQexec
+[NO_PID]: ecpg_execute on line 37: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 37: Correctly got 1 tuples with 1 fields
+[NO_PID]: ecpg_execute on line 37: correctly got 1 tuples with 1 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 37: RESULT: regress1 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 37: RESULT: regress1 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: raising sqlcode -220 in line 40, 'No such connection first in line 40.'.
+[NO_PID]: raising sqlcode -220 on line 40: no such connection first on line 40
[NO_PID]: sqlca: code: -220, state: 08003
-[NO_PID]: ecpg_finish: Connection second closed.
+[NO_PID]: ecpg_finish: connection second closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 27: QUERY: select current_database () with 0 parameter on connection second
+[NO_PID]: ecpg_execute on line 27: query: select current_database () ; with 0 parameter(s) on connection second
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 27: using PQexec
+[NO_PID]: ecpg_execute on line 27: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 27: Correctly got 1 tuples with 1 fields
+[NO_PID]: ecpg_execute on line 27: correctly got 1 tuples with 1 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 27: RESULT: regress1 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 27: RESULT: regress1 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection second closed.
+[NO_PID]: ecpg_finish: connection second closed
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 31: QUERY: select current_database () with 0 parameter on connection first
+[NO_PID]: ecpg_execute on line 31: query: select current_database () ; with 0 parameter(s) on connection first
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 31: using PQexec
+[NO_PID]: ecpg_execute on line 31: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 31: Correctly got 1 tuples with 1 fields
+[NO_PID]: ecpg_execute on line 31: correctly got 1 tuples with 1 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 31: RESULT: connectdb offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 31: RESULT: connectdb offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: raising sqlcode -220 in line 35, 'No such connection DEFAULT in line 35.'.
+[NO_PID]: raising sqlcode -220 on line 35: no such connection DEFAULT on line 35
[NO_PID]: sqlca: code: -220, state: 08003
[NO_PID]: ECPGconnect: connection identifier second is already in use
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection second closed.
+[NO_PID]: ecpg_finish: connection second closed
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection first closed.
+[NO_PID]: ecpg_finish: connection first closed
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: raising sqlcode -220 in line 40, 'No such connection CURRENT in line 40.'.
+[NO_PID]: raising sqlcode -220 on line 40: no such connection CURRENT on line 40
[NO_PID]: sqlca: code: -220, state: 08003
-[NO_PID]: raising sqlcode -220 in line 41, 'No such connection DEFAULT in line 41.'.
+[NO_PID]: raising sqlcode -220 on line 41: no such connection DEFAULT on line 41
[NO_PID]: sqlca: code: -220, state: 08003
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: raising sqlcode -220 in line 17, 'No such connection DEFAULT in line 17.'.
+[NO_PID]: raising sqlcode -220 on line 17: no such connection DEFAULT on line 17
[NO_PID]: sqlca: code: -220, state: 08003
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database connectdb on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 24: QUERY: alter user connectuser encrypted password 'connectpw' with 0 parameter on connection main
+[NO_PID]: ecpg_execute on line 24: query: alter user connectuser encrypted password 'connectpw'; with 0 parameter(s) on connection main
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 24: using PQexec
+[NO_PID]: ecpg_execute on line 24: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 24 Ok: ALTER ROLE
+[NO_PID]: ecpg_execute on line 24: OK: ALTER ROLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection main closed.
+[NO_PID]: ecpg_finish: connection main closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database connectdb on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection main closed.
+[NO_PID]: ecpg_finish: connection main closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database connectdb on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection main closed.
+[NO_PID]: ecpg_finish: connection main closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database connectdb on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection main closed.
+[NO_PID]: ecpg_finish: connection main closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database connectdb on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection main closed.
+[NO_PID]: ecpg_finish: connection main closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database <DEFAULT> on <DEFAULT> port <DEFAULT> for user connectdb
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection main closed.
+[NO_PID]: ecpg_finish: connection main closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database connectdb on <DEFAULT> port <DEFAULT> for user connectuser
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection main closed.
+[NO_PID]: ecpg_finish: connection main closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database connectdb on <DEFAULT> port <DEFAULT> for user connectuser
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection main closed.
+[NO_PID]: ecpg_finish: connection main closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database connectdb on <DEFAULT> port <DEFAULT> for user connectuser
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection main closed.
+[NO_PID]: ecpg_finish: connection main closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database connectdb on <DEFAULT> port <DEFAULT> for user connectuser
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection main closed.
+[NO_PID]: ecpg_finish: connection main closed
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGconnect: non-localhost access via sockets in line 56
+[NO_PID]: ECPGconnect: non-localhost access via sockets on line 56
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: raising sqlcode -402 in line 56, 'Could not connect to database connectdb in line 56.'.
+[NO_PID]: raising sqlcode -402 on line 56: could not connect to database "connectdb" on line 56
[NO_PID]: sqlca: code: -402, state: 08001
-[NO_PID]: raising sqlcode -220 in line 57, 'No such connection main in line 57.'.
+[NO_PID]: raising sqlcode -220 on line 57: no such connection main on line 57
[NO_PID]: sqlca: code: -220, state: 08003
[NO_PID]: ECPGconnect: opening database <DEFAULT> on <DEFAULT> port <DEFAULT> for user connectdb
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection main closed.
+[NO_PID]: ecpg_finish: connection main closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database connectdb on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: connection identifier main is already in use
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection main closed.
+[NO_PID]: ecpg_finish: connection main closed
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: raising sqlcode -220 in line 68, 'No such connection nonexistant in line 68.'.
+[NO_PID]: raising sqlcode -220 on line 68: no such connection nonexistant on line 68
[NO_PID]: sqlca: code: -220, state: 08003
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 29: QUERY: create table date_test ( d date , ts timestamp ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 29: query: create table date_test ( d date , ts timestamp ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 29: using PQexec
+[NO_PID]: ecpg_execute on line 29: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 29 Ok: CREATE TABLE
+[NO_PID]: ecpg_execute on line 29: OK: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 30: QUERY: set datestyle to iso with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 30: query: set datestyle to iso; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 30: using PQexec
+[NO_PID]: ecpg_execute on line 30: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 30 Ok: SET
+[NO_PID]: ecpg_execute on line 30: OK: SET
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35: QUERY: insert into date_test ( d , ts ) values ( $1 , $2 ) with 2 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 35: query: insert into date_test ( d , ts ) values ( $1 , $2 ) ; with 2 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35: using PQexecParams
+[NO_PID]: ecpg_execute on line 35: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 35: parameter 1 = 1966-01-17
+[NO_PID]: free_params on line 35: parameter 1 = 1966-01-17
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 35: parameter 2 = 2000-07-12 17:34:29
+[NO_PID]: free_params on line 35: parameter 2 = 2000-07-12 17:34:29
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 35: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 37: QUERY: select * from date_test where d = $1 with 1 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 37: query: select * from date_test where d = $1 ; with 1 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 37: using PQexecParams
+[NO_PID]: ecpg_execute on line 37: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 37: parameter 1 = 1966-01-17
+[NO_PID]: free_params on line 37: parameter 1 = 1966-01-17
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 37: Correctly got 1 tuples with 2 fields
+[NO_PID]: ecpg_execute on line 37: correctly got 1 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 37: RESULT: 1966-01-17 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 37: RESULT: 1966-01-17 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 37: RESULT: 2000-07-12 17:34:29 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 37: RESULT: 2000-07-12 17:34:29 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 350 action = rollback connection = regress1
+[NO_PID]: ECPGtrans on line 350: action "rollback"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection regress1 closed.
+[NO_PID]: ecpg_finish: connection regress1 closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGsetcommit line 34 action = off connection = regress1
+[NO_PID]: ECPGsetcommit on line 34: action "off"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35: QUERY: create table test ( text char ( 5 ) , num numeric ( 14 , 7 ) ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 35: query: create table test ( text char ( 5 ) , num numeric ( 14 , 7 ) ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35: using PQexec
+[NO_PID]: ecpg_execute on line 35: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35 Ok: CREATE TABLE
+[NO_PID]: ecpg_execute on line 35: OK: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 60: QUERY: insert into test ( text , num ) values ( 'test' , $1 ) with 1 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 60: query: insert into test ( text , num ) values ( 'test' , $1 ) ; with 1 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 60: using PQexecParams
+[NO_PID]: ecpg_execute on line 60: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 60: parameter 1 = 2369.7
+[NO_PID]: free_params on line 60: parameter 1 = 2369.7
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 60 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 60: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 66: QUERY: select num from test where text = 'test' with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 66: query: select num from test where text = 'test' ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 66: using PQexec
+[NO_PID]: ecpg_execute on line 66: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 66: Correctly got 1 tuples with 1 fields
+[NO_PID]: ecpg_execute on line 66: correctly got 1 tuples with 1 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 66: RESULT: 2369.7000000 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 66: RESULT: 2369.7000000 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 90 action = rollback connection = regress1
+[NO_PID]: ECPGtrans on line 90: action "rollback"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection regress1 closed.
+[NO_PID]: ecpg_finish: connection regress1 closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 52: QUERY: create table customers ( c varchar ( 50 ) , p int ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 52: query: create table customers ( c varchar ( 50 ) , p int ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 52: using PQexec
+[NO_PID]: ecpg_execute on line 52: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 52 Ok: CREATE TABLE
+[NO_PID]: ecpg_execute on line 52: OK: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 53: QUERY: insert into customers values ( 'John Doe' , '12345' ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 53: query: insert into customers values ( 'John Doe' , '12345' ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 53: using PQexec
+[NO_PID]: ecpg_execute on line 53: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 53 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 53: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 54: QUERY: insert into customers values ( 'Jane Doe' , '67890' ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 54: query: insert into customers values ( 'Jane Doe' , '67890' ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 54: using PQexec
+[NO_PID]: ecpg_execute on line 54: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 54 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 54: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 56: QUERY: select * from customers limit 2 with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 56: query: select * from customers limit 2 ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 56: using PQexec
+[NO_PID]: ecpg_execute on line 56: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 56: Correctly got 2 tuples with 2 fields
+[NO_PID]: ecpg_execute on line 56: correctly got 2 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 56: RESULT: John Doe offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 56: RESULT: John Doe offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 56: RESULT: Jane Doe offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 56: RESULT: Jane Doe offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 56: RESULT: 12345 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 56: RESULT: 12345 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 56: RESULT: 67890 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 56: RESULT: 67890 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 64: QUERY: select * from customers limit 2 with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 64: query: select * from customers limit 2 ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 64: using PQexec
+[NO_PID]: ecpg_execute on line 64: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 64: Correctly got 2 tuples with 2 fields
+[NO_PID]: ecpg_execute on line 64: correctly got 2 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 64: RESULT: John Doe offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 64: RESULT: John Doe offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 64: RESULT: Jane Doe offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 64: RESULT: Jane Doe offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 64: RESULT: 12345 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 64: RESULT: 12345 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 64: RESULT: 67890 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 64: RESULT: 67890 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 72: QUERY: select * from customers limit 2 with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 72: query: select * from customers limit 2 ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 72: using PQexec
+[NO_PID]: ecpg_execute on line 72: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 72: Correctly got 2 tuples with 2 fields
+[NO_PID]: ecpg_execute on line 72: correctly got 2 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 72: RESULT: John Doe offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 72: RESULT: John Doe offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 72: RESULT: Jane Doe offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 72: RESULT: Jane Doe offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 72: RESULT: 12345 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 72: RESULT: 12345 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 72: RESULT: 67890 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 72: RESULT: 67890 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 80: QUERY: select * from customers limit 1 with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 80: query: select * from customers limit 1 ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 80: using PQexec
+[NO_PID]: ecpg_execute on line 80: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 80: Correctly got 1 tuples with 2 fields
+[NO_PID]: ecpg_execute on line 80: correctly got 1 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 80: RESULT: John Doe offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 80: RESULT: John Doe offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 80: RESULT: 12345 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 80: RESULT: 12345 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 85: QUERY: select c from customers limit 2 with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 85: query: select c from customers limit 2 ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 85: using PQexec
+[NO_PID]: ecpg_execute on line 85: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 85: Correctly got 2 tuples with 1 fields
+[NO_PID]: ecpg_execute on line 85: correctly got 2 tuples with 1 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 85: RESULT: John Doe offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 85: RESULT: John Doe offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 85: RESULT: Jane Doe offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 85: RESULT: Jane Doe offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection regress1 closed.
+[NO_PID]: ecpg_finish: connection regress1 closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_auto_prepare line 19: stmt not in cache; inserting
+[NO_PID]: ecpg_auto_prepare on line 19: statement not in cache; inserting
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGprepare line 19: NAME: ecpg1 QUERY: create table T ( Item1 int , Item2 int )
+[NO_PID]: ECPGprepare on line 19: name ecpg1; query: "create table T ( Item1 int , Item2 int ) "
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 19: QUERY: create table T ( Item1 int , Item2 int ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 19: query: create table T ( Item1 int , Item2 int ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 19: using PQexecPrepared for create table T ( Item1 int , Item2 int )
+[NO_PID]: ecpg_execute on line 19: using PQexecPrepared for "create table T ( Item1 int , Item2 int ) "
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 19 Ok: CREATE TABLE
+[NO_PID]: ecpg_execute on line 19: OK: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_auto_prepare line 21: stmt not in cache; inserting
+[NO_PID]: ecpg_auto_prepare on line 21: statement not in cache; inserting
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGprepare line 21: NAME: ecpg2 QUERY: insert into T values ( 1 , null )
+[NO_PID]: ECPGprepare on line 21: name ecpg2; query: "insert into T values ( 1 , null ) "
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 21: QUERY: insert into T values ( 1 , null ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 21: query: insert into T values ( 1 , null ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 21: using PQexecPrepared for insert into T values ( 1 , null )
+[NO_PID]: ecpg_execute on line 21: using PQexecPrepared for "insert into T values ( 1 , null ) "
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 21 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 21: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_auto_prepare line 22: stmt not in cache; inserting
+[NO_PID]: ecpg_auto_prepare on line 22: statement not in cache; inserting
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGprepare line 22: NAME: ecpg3 QUERY: insert into T values ( 1 , $1 )
+[NO_PID]: ECPGprepare on line 22: name ecpg3; query: "insert into T values ( 1 , $1 ) "
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 22: QUERY: insert into T values ( 1 , $1 ) with 1 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 22: query: insert into T values ( 1 , $1 ) ; with 1 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 22: using PQexecPrepared for insert into T values ( 1 , $1 )
+[NO_PID]: ecpg_execute on line 22: using PQexecPrepared for "insert into T values ( 1 , $1 ) "
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 22: parameter 1 = 1
+[NO_PID]: free_params on line 22: parameter 1 = 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 22 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 22: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_auto_prepare line 24: stmt found in cache, entry 6248
+[NO_PID]: ecpg_auto_prepare on line 24: statement found in cache; entry 6248
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 24: QUERY: insert into T values ( 1 , $1 ) with 1 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 24: query: insert into T values ( 1 , $1 ) ; with 1 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 24: using PQexecPrepared for insert into T values ( 1 , $1 )
+[NO_PID]: ecpg_execute on line 24: using PQexecPrepared for "insert into T values ( 1 , $1 ) "
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 24: parameter 1 = 2
+[NO_PID]: free_params on line 24: parameter 1 = 2
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 24 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 24: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGprepare line 25: NAME: i QUERY: insert into T values ( 1 , 2 )
+[NO_PID]: ECPGprepare on line 25: name i; query: " insert into T values ( 1 , 2 ) "
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26: QUERY: insert into T values ( 1 , 2 ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 26: query: insert into T values ( 1 , 2 ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26: using PQexecPrepared for insert into T values ( 1 , 2 )
+[NO_PID]: ecpg_execute on line 26: using PQexecPrepared for " insert into T values ( 1 , 2 ) "
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 26: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_auto_prepare line 28: stmt not in cache; inserting
+[NO_PID]: ecpg_auto_prepare on line 28: statement not in cache; inserting
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGprepare line 28: NAME: ecpg4 QUERY: select Item2 from T order by Item2 nulls last
+[NO_PID]: ECPGprepare on line 28: name ecpg4; query: "select Item2 from T order by Item2 nulls last"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 28: QUERY: select Item2 from T order by Item2 nulls last with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 28: query: select Item2 from T order by Item2 nulls last; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 28: using PQexecPrepared for select Item2 from T order by Item2 nulls last
+[NO_PID]: ecpg_execute on line 28: using PQexecPrepared for "select Item2 from T order by Item2 nulls last"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 28: Correctly got 4 tuples with 1 fields
+[NO_PID]: ecpg_execute on line 28: correctly got 4 tuples with 1 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 28: RESULT: 1 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 28: RESULT: 1 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 28: RESULT: 2 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 28: RESULT: 2 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 28: RESULT: 2 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 28: RESULT: 2 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 28: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 28: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_auto_prepare line 35: stmt not in cache; inserting
+[NO_PID]: ecpg_auto_prepare on line 35: statement not in cache; inserting
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGprepare line 35: NAME: ecpg5 QUERY: declare C cursor for select Item1 from T
+[NO_PID]: ECPGprepare on line 35: name ecpg5; query: "declare C cursor for select Item1 from T "
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35: QUERY: declare C cursor for select Item1 from T with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 35: query: declare C cursor for select Item1 from T ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35: using PQexecPrepared for declare C cursor for select Item1 from T
+[NO_PID]: ecpg_execute on line 35: using PQexecPrepared for "declare C cursor for select Item1 from T "
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35 Ok: DECLARE CURSOR
+[NO_PID]: ecpg_execute on line 35: OK: DECLARE CURSOR
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_auto_prepare line 37: stmt not in cache; inserting
+[NO_PID]: ecpg_auto_prepare on line 37: statement not in cache; inserting
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGprepare line 37: NAME: ecpg6 QUERY: fetch 1 in C
+[NO_PID]: ECPGprepare on line 37: name ecpg6; query: "fetch 1 in C"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 37: QUERY: fetch 1 in C with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 37: query: fetch 1 in C; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 37: using PQexecPrepared for fetch 1 in C
+[NO_PID]: ecpg_execute on line 37: using PQexecPrepared for "fetch 1 in C"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 37: Correctly got 1 tuples with 1 fields
+[NO_PID]: ecpg_execute on line 37: correctly got 1 tuples with 1 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 37: RESULT: 1 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 37: RESULT: 1 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_auto_prepare line 40: stmt not in cache; inserting
+[NO_PID]: ecpg_auto_prepare on line 40: statement not in cache; inserting
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGprepare line 40: NAME: ecpg7 QUERY: close C
+[NO_PID]: ECPGprepare on line 40: name ecpg7; query: "close C"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 40: QUERY: close C with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 40: query: close C; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 40: using PQexecPrepared for close C
+[NO_PID]: ecpg_execute on line 40: using PQexecPrepared for "close C"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 40 Ok: CLOSE CURSOR
+[NO_PID]: ecpg_execute on line 40: OK: CLOSE CURSOR
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_auto_prepare line 42: stmt not in cache; inserting
+[NO_PID]: ecpg_auto_prepare on line 42: statement not in cache; inserting
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGprepare line 42: NAME: ecpg8 QUERY: drop table T
+[NO_PID]: ECPGprepare on line 42: name ecpg8; query: "drop table T "
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 42: QUERY: drop table T with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 42: query: drop table T ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 42: using PQexecPrepared for drop table T
+[NO_PID]: ecpg_execute on line 42: using PQexecPrepared for "drop table T "
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 42 Ok: DROP TABLE
+[NO_PID]: ecpg_execute on line 42: OK: DROP TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGdeallocate line 0: NAME: ecpg8
+[NO_PID]: ECPGdeallocate on line 0: name ecpg8
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGdeallocate line 0: NAME: ecpg7
+[NO_PID]: ECPGdeallocate on line 0: name ecpg7
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGdeallocate line 0: NAME: ecpg6
+[NO_PID]: ECPGdeallocate on line 0: name ecpg6
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGdeallocate line 0: NAME: ecpg5
+[NO_PID]: ECPGdeallocate on line 0: name ecpg5
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGdeallocate line 0: NAME: ecpg4
+[NO_PID]: ECPGdeallocate on line 0: name ecpg4
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGdeallocate line 0: NAME: i
+[NO_PID]: ECPGdeallocate on line 0: name i
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGdeallocate line 0: NAME: ecpg3
+[NO_PID]: ECPGdeallocate on line 0: name ecpg3
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGdeallocate line 0: NAME: ecpg2
+[NO_PID]: ECPGdeallocate on line 0: name ecpg2
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGdeallocate line 0: NAME: ecpg1
+[NO_PID]: ECPGdeallocate on line 0: name ecpg1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection regress1 closed.
+[NO_PID]: ecpg_finish: connection regress1 closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection regress1 closed.
+[NO_PID]: ecpg_finish: connection regress1 closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 36: QUERY: create table test ( name char ( 8 ) , amount int , letter char ( 1 ) ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 36: query: create table test ( name char ( 8 ) , amount int , letter char ( 1 ) ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 36: using PQexec
+[NO_PID]: ecpg_execute on line 36: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 36 Ok: CREATE TABLE
+[NO_PID]: ecpg_execute on line 36: OK: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 37 action = commit connection = regress1
+[NO_PID]: ECPGtrans on line 37: action "commit"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 39: QUERY: insert into Test ( name , amount , letter ) values ( 'false' , 1 , 'f' ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 39: query: insert into Test ( name , amount , letter ) values ( 'false' , 1 , 'f' ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 39: using PQexec
+[NO_PID]: ecpg_execute on line 39: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 39 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 39: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 40: QUERY: insert into test ( name , amount , letter ) values ( 'true' , 2 , 't' ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 40: query: insert into test ( name , amount , letter ) values ( 'true' , 2 , 't' ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 40: using PQexec
+[NO_PID]: ecpg_execute on line 40: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 40 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 40: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 41 action = commit connection = regress1
+[NO_PID]: ECPGtrans on line 41: action "commit"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 43: QUERY: select * from test with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 43: query: select * from test ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 43: using PQexec
+[NO_PID]: ecpg_execute on line 43: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 43: Correctly got 2 tuples with 3 fields
+[NO_PID]: ecpg_execute on line 43: correctly got 2 tuples with 3 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 43: RESULT: false offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 43: RESULT: false offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 43: RESULT: true offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 43: RESULT: true offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 43: RESULT: 1 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 43: RESULT: 1 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 43: RESULT: 2 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 43: RESULT: 2 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 43: RESULT: f offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 43: RESULT: f offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 43: RESULT: t offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 43: RESULT: t offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 56: QUERY: drop table test with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 56: query: drop table test ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 56: using PQexec
+[NO_PID]: ecpg_execute on line 56: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 56 Ok: DROP TABLE
+[NO_PID]: ecpg_execute on line 56: OK: DROP TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 57 action = commit connection = regress1
+[NO_PID]: ECPGtrans on line 57: action "commit"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection regress1 closed.
+[NO_PID]: ecpg_finish: connection regress1 closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGdebug: set to 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: raising sqlcode -220 in line 88, 'No such connection NULL in line 88.'.
+[NO_PID]: raising sqlcode -220 on line 88: no such connection NULL on line 88
[NO_PID]: sqlca: code: -220, state: 08003
-[NO_PID]: raising sqlcode -220 in line 90, 'No such connection NULL in line 90.'.
+[NO_PID]: raising sqlcode -220 on line 90: no such connection NULL on line 90
[NO_PID]: sqlca: code: -220, state: 08003
-[NO_PID]: raising sqlcode -220 in line 92, 'No such connection NULL in line 92.'.
+[NO_PID]: raising sqlcode -220 on line 92: no such connection NULL on line 92
[NO_PID]: sqlca: code: -220, state: 08003
-[NO_PID]: raising sqlcode -220 in line 94, 'No such connection NULL in line 94.'.
+[NO_PID]: raising sqlcode -220 on line 94: no such connection NULL on line 94
[NO_PID]: sqlca: code: -220, state: 08003
-[NO_PID]: raising sqlcode -220 in line 96, 'No such connection NULL in line 96.'.
+[NO_PID]: raising sqlcode -220 on line 96: no such connection NULL on line 96
[NO_PID]: sqlca: code: -220, state: 08003
-[NO_PID]: raising sqlcode -220 in line 98, 'No such connection NULL in line 98.'.
+[NO_PID]: raising sqlcode -220 on line 98: no such connection NULL on line 98
[NO_PID]: sqlca: code: -220, state: 08003
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 50: QUERY: create table empl ( idnum integer , name char ( 20 ) , accs smallint , string1 char ( 10 ) , string2 char ( 10 ) , string3 char ( 10 ) ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 50: query: create table empl ( idnum integer , name char ( 20 ) , accs smallint , string1 char ( 10 ) , string2 char ( 10 ) , string3 char ( 10 ) ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 50: using PQexec
+[NO_PID]: ecpg_execute on line 50: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 50 Ok: CREATE TABLE
+[NO_PID]: ecpg_execute on line 50: OK: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 58: QUERY: insert into empl values ( 1 , 'user name' , 320 , 'first str' , 'second str' , 'third str' ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 58: query: insert into empl values ( 1 , 'user name' , 320 , 'first str' , 'second str' , 'third str' ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 58: using PQexec
+[NO_PID]: ecpg_execute on line 58: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 58 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 58: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 65: QUERY: select idnum , name , accs , string1 , string2 , string3 from empl where idnum = $1 with 1 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 65: query: select idnum , name , accs , string1 , string2 , string3 from empl where idnum = $1 ; with 1 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 65: using PQexecParams
+[NO_PID]: ecpg_execute on line 65: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 65: parameter 1 = 1
+[NO_PID]: free_params on line 65: parameter 1 = 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 65: Correctly got 1 tuples with 6 fields
+[NO_PID]: ecpg_execute on line 65: correctly got 1 tuples with 6 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 65: RESULT: 1 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 65: RESULT: 1 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 65: RESULT: user name offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 65: RESULT: user name offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 65: RESULT: 320 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 65: RESULT: 320 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 65: RESULT: first str offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 65: RESULT: first str offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_store_result: line 65: allocating memory for 1 tuples
+[NO_PID]: ecpg_store_result on line 65: allocating memory for 1 tuples
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 65: RESULT: second str offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 65: RESULT: second str offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 65: RESULT: third str offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 65: RESULT: third str offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection regress1 closed.
+[NO_PID]: ecpg_finish: connection regress1 closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 46: QUERY: set datestyle to iso with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 46: query: set datestyle to iso; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 46: using PQexec
+[NO_PID]: ecpg_execute on line 46: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 46 Ok: SET
+[NO_PID]: ecpg_execute on line 46: OK: SET
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 49: QUERY: create table family ( name char ( 8 ) , born integer , age smallint , married date , children integer ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 49: query: create table family ( name char ( 8 ) , born integer , age smallint , married date , children integer ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 49: using PQexec
+[NO_PID]: ecpg_execute on line 49: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 49 Ok: CREATE TABLE
+[NO_PID]: ecpg_execute on line 49: OK: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 52: QUERY: insert into family ( name , married , children ) values ( 'Mum' , '19870714' , 3 ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 52: query: insert into family ( name , married , children ) values ( 'Mum' , '19870714' , 3 ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 52: using PQexec
+[NO_PID]: ecpg_execute on line 52: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 52 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 52: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 53: QUERY: insert into family ( name , born , married , children ) values ( 'Dad' , '19610721' , '19870714' , 3 ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 53: query: insert into family ( name , born , married , children ) values ( 'Dad' , '19610721' , '19870714' , 3 ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 53: using PQexec
+[NO_PID]: ecpg_execute on line 53: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 53 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 53: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 54: QUERY: insert into family ( name , age ) values ( 'Child 1' , 16 ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 54: query: insert into family ( name , age ) values ( 'Child 1' , 16 ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 54: using PQexec
+[NO_PID]: ecpg_execute on line 54: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 54 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 54: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 55: QUERY: insert into family ( name , age ) values ( 'Child 2' , 14 ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 55: query: insert into family ( name , age ) values ( 'Child 2' , 14 ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 55: using PQexec
+[NO_PID]: ecpg_execute on line 55: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 55 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 55: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 56: QUERY: insert into family ( name , age ) values ( 'Child 3' , 9 ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 56: query: insert into family ( name , age ) values ( 'Child 3' , 9 ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 56: using PQexec
+[NO_PID]: ecpg_execute on line 56: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 56 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 56: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 59 action = commit connection = regress1
+[NO_PID]: ECPGtrans on line 59: action "commit"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 62: QUERY: declare cur cursor for select name , born , age , married , children from family with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 62: query: declare cur cursor for select name , born , age , married , children from family ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 62: using PQexec
+[NO_PID]: ecpg_execute on line 62: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 62 Ok: DECLARE CURSOR
+[NO_PID]: ecpg_execute on line 62: OK: DECLARE CURSOR
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 71: QUERY: fetch cur with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 71: query: fetch cur; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 71: using PQexec
+[NO_PID]: ecpg_execute on line 71: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 71: Correctly got 1 tuples with 5 fields
+[NO_PID]: ecpg_execute on line 71: correctly got 1 tuples with 5 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 71: RESULT: Mum offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 71: RESULT: Mum offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 71: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 71: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 71: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 71: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_store_result: line 71: allocating memory for 1 tuples
+[NO_PID]: ecpg_store_result on line 71: allocating memory for 1 tuples
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 71: RESULT: 1987-07-14 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 71: RESULT: 1987-07-14 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 71: RESULT: 3 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 71: RESULT: 3 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 71: QUERY: fetch cur with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 71: query: fetch cur; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 71: using PQexec
+[NO_PID]: ecpg_execute on line 71: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 71: Correctly got 1 tuples with 5 fields
+[NO_PID]: ecpg_execute on line 71: correctly got 1 tuples with 5 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 71: RESULT: Dad offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 71: RESULT: Dad offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 71: RESULT: 19610721 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 71: RESULT: 19610721 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 71: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 71: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_store_result: line 71: allocating memory for 1 tuples
+[NO_PID]: ecpg_store_result on line 71: allocating memory for 1 tuples
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 71: RESULT: 1987-07-14 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 71: RESULT: 1987-07-14 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 71: RESULT: 3 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 71: RESULT: 3 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 71: QUERY: fetch cur with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 71: query: fetch cur; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 71: using PQexec
+[NO_PID]: ecpg_execute on line 71: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 71: Correctly got 1 tuples with 5 fields
+[NO_PID]: ecpg_execute on line 71: correctly got 1 tuples with 5 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 71: RESULT: Child 1 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 71: RESULT: Child 1 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 71: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 71: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 71: RESULT: 16 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 71: RESULT: 16 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_store_result: line 71: allocating memory for 1 tuples
+[NO_PID]: ecpg_store_result on line 71: allocating memory for 1 tuples
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 71: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 71: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 71: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 71: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 71: QUERY: fetch cur with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 71: query: fetch cur; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 71: using PQexec
+[NO_PID]: ecpg_execute on line 71: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 71: Correctly got 1 tuples with 5 fields
+[NO_PID]: ecpg_execute on line 71: correctly got 1 tuples with 5 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 71: RESULT: Child 2 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 71: RESULT: Child 2 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 71: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 71: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 71: RESULT: 14 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 71: RESULT: 14 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_store_result: line 71: allocating memory for 1 tuples
+[NO_PID]: ecpg_store_result on line 71: allocating memory for 1 tuples
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 71: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 71: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 71: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 71: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 71: QUERY: fetch cur with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 71: query: fetch cur; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 71: using PQexec
+[NO_PID]: ecpg_execute on line 71: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 71: Correctly got 1 tuples with 5 fields
+[NO_PID]: ecpg_execute on line 71: correctly got 1 tuples with 5 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 71: RESULT: Child 3 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 71: RESULT: Child 3 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 71: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 71: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 71: RESULT: 9 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 71: RESULT: 9 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_store_result: line 71: allocating memory for 1 tuples
+[NO_PID]: ecpg_store_result on line 71: allocating memory for 1 tuples
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 71: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 71: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 71: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 71: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 71: QUERY: fetch cur with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 71: query: fetch cur; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 71: using PQexec
+[NO_PID]: ecpg_execute on line 71: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 71: Correctly got 0 tuples with 5 fields
+[NO_PID]: ecpg_execute on line 71: correctly got 0 tuples with 5 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: raising sqlcode 100 in line 71, 'No data found in line 71.'.
+[NO_PID]: raising sqlcode 100 on line 71: no data found on line 71
[NO_PID]: sqlca: code: 100, state: 02000
-[NO_PID]: ecpg_execute line 88: QUERY: close cur with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 88: query: close cur; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 88: using PQexec
+[NO_PID]: ecpg_execute on line 88: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 88 Ok: CLOSE CURSOR
+[NO_PID]: ecpg_execute on line 88: OK: CLOSE CURSOR
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 91: QUERY: drop table family with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 91: query: drop table family ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 91: using PQexec
+[NO_PID]: ecpg_execute on line 91: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 91 Ok: DROP TABLE
+[NO_PID]: ecpg_execute on line 91: OK: DROP TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 94 action = commit connection = regress1
+[NO_PID]: ECPGtrans on line 94: action "commit"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection regress1 closed.
+[NO_PID]: ecpg_finish: connection regress1 closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 32: QUERY: create table test ( i int , c char ( 10 ) ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 32: query: create table test ( i int , c char ( 10 ) ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 32: using PQexec
+[NO_PID]: ecpg_execute on line 32: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 32 Ok: CREATE TABLE
+[NO_PID]: ecpg_execute on line 32: OK: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 33: QUERY: insert into test values ( 1 , 'abcdefghij' ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 33: query: insert into test values ( 1 , 'abcdefghij' ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 33: using PQexec
+[NO_PID]: ecpg_execute on line 33: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 33 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 33: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 36: QUERY: select * from test with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 36: query: select * from test ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 36: using PQexec
+[NO_PID]: ecpg_execute on line 36: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 36: Correctly got 1 tuples with 2 fields
+[NO_PID]: ecpg_execute on line 36: correctly got 1 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 36: RESULT: 1 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 36: RESULT: 1 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 36: RESULT: abcdefghij offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 36: RESULT: abcdefghij offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
Warning: At least one column was truncated
-[NO_PID]: ECPGtrans line 37 action = rollback connection = regress1
+[NO_PID]: ECPGtrans on line 37: action "rollback"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 39: QUERY: select * from nonexistant with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 39: query: select * from nonexistant ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 39: using PQexec
+[NO_PID]: ecpg_execute on line 39: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_check_PQresult line 39: Error: ERROR: relation "nonexistant" does not exist
+[NO_PID]: ecpg_check_PQresult on line 39: ERROR: relation "nonexistant" does not exist
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: raising sqlstate 42P01 (sqlcode: -400) in line 39, ''relation "nonexistant" does not exist' in line 39.'.
+[NO_PID]: raising sqlstate 42P01 (sqlcode -400) on line 39: relation "nonexistant" does not exist on line 39
[NO_PID]: sqlca: code: -400, state: 42P01
-sql error 'relation "nonexistant" does not exist' in line 39.
-[NO_PID]: ECPGtrans line 40 action = rollback connection = regress1
+sql error: relation "nonexistant" does not exist on line 39
+[NO_PID]: ECPGtrans on line 40: action "rollback"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 43: QUERY: select * from nonexistant with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 43: query: select * from nonexistant ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 43: using PQexec
+[NO_PID]: ecpg_execute on line 43: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_check_PQresult line 43: Error: ERROR: relation "nonexistant" does not exist
+[NO_PID]: ecpg_check_PQresult on line 43: ERROR: relation "nonexistant" does not exist
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: raising sqlstate 42P01 (sqlcode: -400) in line 43, ''relation "nonexistant" does not exist' in line 43.'.
+[NO_PID]: raising sqlstate 42P01 (sqlcode -400) on line 43: relation "nonexistant" does not exist on line 43
[NO_PID]: sqlca: code: -400, state: 42P01
Error in statement 'select':
-sql error 'relation "nonexistant" does not exist' in line 43.
-[NO_PID]: ECPGtrans line 44 action = rollback connection = regress1
+sql error: relation "nonexistant" does not exist on line 43
+[NO_PID]: ECPGtrans on line 44: action "rollback"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 47: QUERY: select * from nonexistant with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 47: query: select * from nonexistant ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 47: using PQexec
+[NO_PID]: ecpg_execute on line 47: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_check_PQresult line 47: Error: ERROR: relation "nonexistant" does not exist
+[NO_PID]: ecpg_check_PQresult on line 47: ERROR: relation "nonexistant" does not exist
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: raising sqlstate 42P01 (sqlcode: -400) in line 47, ''relation "nonexistant" does not exist' in line 47.'.
+[NO_PID]: raising sqlstate 42P01 (sqlcode -400) on line 47: relation "nonexistant" does not exist on line 47
[NO_PID]: sqlca: code: -400, state: 42P01
Found another error
-sql error 'relation "nonexistant" does not exist' in line 47.
-[NO_PID]: ECPGtrans line 48 action = rollback connection = regress1
+sql error: relation "nonexistant" does not exist on line 47
+[NO_PID]: ECPGtrans on line 48: action "rollback"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 51: QUERY: select * from nonexistant with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 51: query: select * from nonexistant ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 51: using PQexec
+[NO_PID]: ecpg_execute on line 51: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_check_PQresult line 51: Error: ERROR: relation "nonexistant" does not exist
+[NO_PID]: ecpg_check_PQresult on line 51: ERROR: relation "nonexistant" does not exist
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: raising sqlstate 42P01 (sqlcode: -400) in line 51, ''relation "nonexistant" does not exist' in line 51.'.
+[NO_PID]: raising sqlstate 42P01 (sqlcode -400) on line 51: relation "nonexistant" does not exist on line 51
[NO_PID]: sqlca: code: -400, state: 42P01
-[NO_PID]: ECPGtrans line 52 action = rollback connection = regress1
+[NO_PID]: ECPGtrans on line 52: action "rollback"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 55: QUERY: select * from nonexistant with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 55: query: select * from nonexistant ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 55: using PQexec
+[NO_PID]: ecpg_execute on line 55: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_check_PQresult line 55: Error: ERROR: relation "nonexistant" does not exist
+[NO_PID]: ecpg_check_PQresult on line 55: ERROR: relation "nonexistant" does not exist
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: raising sqlstate 42P01 (sqlcode: -400) in line 55, ''relation "nonexistant" does not exist' in line 55.'.
+[NO_PID]: raising sqlstate 42P01 (sqlcode -400) on line 55: relation "nonexistant" does not exist on line 55
[NO_PID]: sqlca: code: -400, state: 42P01
-[NO_PID]: ECPGtrans line 59 action = rollback connection = regress1
+[NO_PID]: ECPGtrans on line 59: action "rollback"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 62: QUERY: select * from nonexistant with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 62: query: select * from nonexistant ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 62: using PQexec
+[NO_PID]: ecpg_execute on line 62: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_check_PQresult line 62: Error: ERROR: relation "nonexistant" does not exist
+[NO_PID]: ecpg_check_PQresult on line 62: ERROR: relation "nonexistant" does not exist
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: raising sqlstate 42P01 (sqlcode: -400) in line 62, ''relation "nonexistant" does not exist' in line 62.'.
+[NO_PID]: raising sqlstate 42P01 (sqlcode -400) on line 62: relation "nonexistant" does not exist on line 62
[NO_PID]: sqlca: code: -400, state: 42P01
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGsetcommit line 29 action = on connection = regress1
+[NO_PID]: ECPGsetcommit on line 29: action "on"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 31 action = begin transaction connection = regress1
+[NO_PID]: ECPGtrans on line 31: action "begin transaction "; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 33: QUERY: create table test ( f float , i int , a int [ 10 ] , text char ( 10 ) ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 33: query: create table test ( f float , i int , a int [ 10 ] , text char ( 10 ) ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 33: using PQexec
+[NO_PID]: ecpg_execute on line 33: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 33 Ok: CREATE TABLE
+[NO_PID]: ecpg_execute on line 33: OK: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35: QUERY: insert into test ( f , i , a , text ) values ( 404.90 , 3 , '{0,1,2,3,4,5,6,7,8,9}' , 'abcdefghij' ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 35: query: insert into test ( f , i , a , text ) values ( 404.90 , 3 , '{0,1,2,3,4,5,6,7,8,9}' , 'abcdefghij' ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35: using PQexec
+[NO_PID]: ecpg_execute on line 35: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 35: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 37: QUERY: insert into test ( f , i , a , text ) values ( 140787.0 , 2 , $1 , $2 ) with 2 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 37: query: insert into test ( f , i , a , text ) values ( 140787.0 , 2 , $1 , $2 ) ; with 2 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 37: using PQexecParams
+[NO_PID]: ecpg_execute on line 37: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 37: parameter 1 = {9,8,7,6,5,4,3,2,1,0}
+[NO_PID]: free_params on line 37: parameter 1 = {9,8,7,6,5,4,3,2,1,0}
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 37: parameter 2 = klmnopqrst
+[NO_PID]: free_params on line 37: parameter 2 = klmnopqrst
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 37 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 37: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 39: QUERY: insert into test ( f , i , a , text ) values ( 14.07 , $1 , $2 , $3 ) with 3 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 39: query: insert into test ( f , i , a , text ) values ( 14.07 , $1 , $2 , $3 ) ; with 3 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 39: using PQexecParams
+[NO_PID]: ecpg_execute on line 39: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 39: parameter 1 = 1
+[NO_PID]: free_params on line 39: parameter 1 = 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 39: parameter 2 = {9,8,7,6,5,4,3,2,1,0}
+[NO_PID]: free_params on line 39: parameter 2 = {9,8,7,6,5,4,3,2,1,0}
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 39: parameter 3 = 0123456789
+[NO_PID]: free_params on line 39: parameter 3 = 0123456789
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 39 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 39: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 41 action = commit connection = regress1
+[NO_PID]: ECPGtrans on line 41: action "commit"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 43 action = begin transaction connection = regress1
+[NO_PID]: ECPGtrans on line 43: action "begin transaction "; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 45: QUERY: select f , text from test where i = 1 with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 45: query: select f , text from test where i = 1 ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 45: using PQexec
+[NO_PID]: ecpg_execute on line 45: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 45: Correctly got 1 tuples with 2 fields
+[NO_PID]: ecpg_execute on line 45: correctly got 1 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 45: RESULT: 14.07 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 45: RESULT: 14.07 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 45: RESULT: 0123456789 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 45: RESULT: 0123456789 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 53: QUERY: select a , text from test where f = $1 with 1 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 53: query: select a , text from test where f = $1 ; with 1 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 53: using PQexecParams
+[NO_PID]: ecpg_execute on line 53: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 53: parameter 1 = 140787
+[NO_PID]: free_params on line 53: parameter 1 = 140787
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 53: Correctly got 1 tuples with 2 fields
+[NO_PID]: ecpg_execute on line 53: correctly got 1 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_is_type_an_array line 53: TYPE database: 1007 C: 5 array: Yes
+[NO_PID]: ecpg_is_type_an_array on line 53: type (1007); C (5); array (yes)
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: {9,8,7,6,5,4,3,2,1,0} offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: {9,8,7,6,5,4,3,2,1,0} offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: klmnopqrst offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: klmnopqrst offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 63: QUERY: select a from test where f = $1 with 1 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 63: query: select a from test where f = $1 ; with 1 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 63: using PQexecParams
+[NO_PID]: ecpg_execute on line 63: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 63: parameter 1 = 140787
+[NO_PID]: free_params on line 63: parameter 1 = 140787
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 63: Correctly got 1 tuples with 1 fields
+[NO_PID]: ecpg_execute on line 63: correctly got 1 tuples with 1 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 63: RESULT: {9,8,7,6,5,4,3,2,1,0} offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 63: RESULT: {9,8,7,6,5,4,3,2,1,0} offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 70: QUERY: drop table test with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 70: query: drop table test ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 70: using PQexec
+[NO_PID]: ecpg_execute on line 70: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 70 Ok: DROP TABLE
+[NO_PID]: ecpg_execute on line 70: OK: DROP TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 72 action = commit connection = regress1
+[NO_PID]: ECPGtrans on line 72: action "commit"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection regress1 closed.
+[NO_PID]: ecpg_finish: connection regress1 closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35: QUERY: create table empl ( idnum integer , name char ( 20 ) , accs smallint , byte bytea ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 35: query: create table empl ( idnum integer , name char ( 20 ) , accs smallint , byte bytea ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35: using PQexec
+[NO_PID]: ecpg_execute on line 35: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35 Ok: CREATE TABLE
+[NO_PID]: ecpg_execute on line 35: OK: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 43: QUERY: insert into empl values ( 1 , 'first user' , 320 , $1 ) with 1 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 43: query: insert into empl values ( 1 , 'first user' , 320 , $1 ) ; with 1 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 43: using PQexecParams
+[NO_PID]: ecpg_execute on line 43: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 43: parameter 1 = \001\155\000\212
+[NO_PID]: free_params on line 43: parameter 1 = \001\155\000\212
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 43 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 43: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 51: QUERY: declare C cursor for select name , accs , byte from empl where idnum = $1 with 1 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 51: query: declare C cursor for select name , accs , byte from empl where idnum = $1 ; with 1 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 51: using PQexecParams
+[NO_PID]: ecpg_execute on line 51: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 51: parameter 1 = 1
+[NO_PID]: free_params on line 51: parameter 1 = 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 51 Ok: DECLARE CURSOR
+[NO_PID]: ecpg_execute on line 51: OK: DECLARE CURSOR
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 52: QUERY: fetch C with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 52: query: fetch C; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 52: using PQexec
+[NO_PID]: ecpg_execute on line 52: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 52: Correctly got 1 tuples with 3 fields
+[NO_PID]: ecpg_execute on line 52: correctly got 1 tuples with 3 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 52: RESULT: first user offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 52: RESULT: first user offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 52: RESULT: 320 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 52: RESULT: 320 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 52: RESULT: \001m\000\212 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 52: RESULT: \001m\000\212 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 64: QUERY: declare B binary cursor for select name , accs , byte from empl where idnum = $1 with 1 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 64: query: declare B binary cursor for select name , accs , byte from empl where idnum = $1 ; with 1 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 64: using PQexecParams
+[NO_PID]: ecpg_execute on line 64: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 64: parameter 1 = 1
+[NO_PID]: free_params on line 64: parameter 1 = 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 64 Ok: DECLARE CURSOR
+[NO_PID]: ecpg_execute on line 64: OK: DECLARE CURSOR
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 65: QUERY: fetch B with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 65: query: fetch B; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 65: using PQexec
+[NO_PID]: ecpg_execute on line 65: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 65: Correctly got 1 tuples with 3 fields
+[NO_PID]: ecpg_execute on line 65: correctly got 1 tuples with 3 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 65: RESULT: BINARY offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 65: RESULT: BINARY offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 65: RESULT: BINARY offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 65: RESULT: BINARY offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 65: RESULT: BINARY offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 65: RESULT: BINARY offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 72: QUERY: close B with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 72: query: close B; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 72: using PQexec
+[NO_PID]: ecpg_execute on line 72: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 72 Ok: CLOSE CURSOR
+[NO_PID]: ecpg_execute on line 72: OK: CLOSE CURSOR
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection regress1 closed.
+[NO_PID]: ecpg_finish: connection regress1 closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 18: QUERY: create table test ( "index" numeric ( 3 ) primary key , "payload" int4 not null ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 18: query: create table test ( "index" numeric ( 3 ) primary key , "payload" int4 not null ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 18: using PQexec
+[NO_PID]: ecpg_execute on line 18: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 18 Ok: CREATE TABLE
+[NO_PID]: ecpg_execute on line 18: OK: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 22 action = commit connection = regress1
+[NO_PID]: ECPGtrans on line 22: action "commit"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26: QUERY: insert into test ( payload , index ) values ( 0 , $1 ) with 1 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 26: query: insert into test ( payload , index ) values ( 0 , $1 ) ; with 1 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26: using PQexecParams
+[NO_PID]: ecpg_execute on line 26: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 26: parameter 1 = 0
+[NO_PID]: free_params on line 26: parameter 1 = 0
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 26: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26: QUERY: insert into test ( payload , index ) values ( 0 , $1 ) with 1 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 26: query: insert into test ( payload , index ) values ( 0 , $1 ) ; with 1 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26: using PQexecParams
+[NO_PID]: ecpg_execute on line 26: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 26: parameter 1 = 1
+[NO_PID]: free_params on line 26: parameter 1 = 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 26: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26: QUERY: insert into test ( payload , index ) values ( 0 , $1 ) with 1 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 26: query: insert into test ( payload , index ) values ( 0 , $1 ) ; with 1 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26: using PQexecParams
+[NO_PID]: ecpg_execute on line 26: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 26: parameter 1 = 2
+[NO_PID]: free_params on line 26: parameter 1 = 2
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 26: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26: QUERY: insert into test ( payload , index ) values ( 0 , $1 ) with 1 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 26: query: insert into test ( payload , index ) values ( 0 , $1 ) ; with 1 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26: using PQexecParams
+[NO_PID]: ecpg_execute on line 26: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 26: parameter 1 = 3
+[NO_PID]: free_params on line 26: parameter 1 = 3
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 26: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26: QUERY: insert into test ( payload , index ) values ( 0 , $1 ) with 1 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 26: query: insert into test ( payload , index ) values ( 0 , $1 ) ; with 1 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26: using PQexecParams
+[NO_PID]: ecpg_execute on line 26: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 26: parameter 1 = 4
+[NO_PID]: free_params on line 26: parameter 1 = 4
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 26: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26: QUERY: insert into test ( payload , index ) values ( 0 , $1 ) with 1 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 26: query: insert into test ( payload , index ) values ( 0 , $1 ) ; with 1 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26: using PQexecParams
+[NO_PID]: ecpg_execute on line 26: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 26: parameter 1 = 5
+[NO_PID]: free_params on line 26: parameter 1 = 5
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 26: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26: QUERY: insert into test ( payload , index ) values ( 0 , $1 ) with 1 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 26: query: insert into test ( payload , index ) values ( 0 , $1 ) ; with 1 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26: using PQexecParams
+[NO_PID]: ecpg_execute on line 26: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 26: parameter 1 = 6
+[NO_PID]: free_params on line 26: parameter 1 = 6
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 26: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26: QUERY: insert into test ( payload , index ) values ( 0 , $1 ) with 1 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 26: query: insert into test ( payload , index ) values ( 0 , $1 ) ; with 1 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26: using PQexecParams
+[NO_PID]: ecpg_execute on line 26: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 26: parameter 1 = 7
+[NO_PID]: free_params on line 26: parameter 1 = 7
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 26: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26: QUERY: insert into test ( payload , index ) values ( 0 , $1 ) with 1 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 26: query: insert into test ( payload , index ) values ( 0 , $1 ) ; with 1 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26: using PQexecParams
+[NO_PID]: ecpg_execute on line 26: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 26: parameter 1 = 8
+[NO_PID]: free_params on line 26: parameter 1 = 8
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 26: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26: QUERY: insert into test ( payload , index ) values ( 0 , $1 ) with 1 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 26: query: insert into test ( payload , index ) values ( 0 , $1 ) ; with 1 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26: using PQexecParams
+[NO_PID]: ecpg_execute on line 26: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 26: parameter 1 = 9
+[NO_PID]: free_params on line 26: parameter 1 = 9
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 26: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 31 action = commit connection = regress1
+[NO_PID]: ECPGtrans on line 31: action "commit"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 34: QUERY: update test set payload = payload + 1 where index = - 1 with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 34: query: update test set payload = payload + 1 where index = - 1 ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 34: using PQexec
+[NO_PID]: ecpg_execute on line 34: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 34 Ok: UPDATE 0
+[NO_PID]: ecpg_execute on line 34: OK: UPDATE 0
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: raising sqlcode 100 in line 34, 'No data found in line 34.'.
+[NO_PID]: raising sqlcode 100 on line 34: no data found on line 34
[NO_PID]: sqlca: code: 100, state: 02000
-[NO_PID]: ecpg_execute line 38: QUERY: delete from test where index = - 1 with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 38: query: delete from test where index = - 1 ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 38: using PQexec
+[NO_PID]: ecpg_execute on line 38: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 38 Ok: DELETE 0
+[NO_PID]: ecpg_execute on line 38: OK: DELETE 0
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: raising sqlcode 100 in line 38, 'No data found in line 38.'.
+[NO_PID]: raising sqlcode 100 on line 38: no data found on line 38
[NO_PID]: sqlca: code: 100, state: 02000
-[NO_PID]: ecpg_execute line 41: QUERY: insert into test ( select * from test where index = - 1 ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 41: query: insert into test ( select * from test where index = - 1 ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 41: using PQexec
+[NO_PID]: ecpg_execute on line 41: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 41 Ok: INSERT 0 0
+[NO_PID]: ecpg_execute on line 41: OK: INSERT 0 0
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: raising sqlcode 100 in line 41, 'No data found in line 41.'.
+[NO_PID]: raising sqlcode 100 on line 41: no data found on line 41
[NO_PID]: sqlca: code: 100, state: 02000
-[NO_PID]: ecpg_execute line 44: QUERY: drop table test with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 44: query: drop table test ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 44: using PQexec
+[NO_PID]: ecpg_execute on line 44: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 44 Ok: DROP TABLE
+[NO_PID]: ecpg_execute on line 44: OK: DROP TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 46 action = commit connection = regress1
+[NO_PID]: ECPGtrans on line 46: action "commit"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection regress1 closed.
+[NO_PID]: ecpg_finish: connection regress1 closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 20: QUERY: create table foo ( a int , b varchar ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 20: query: create table foo ( a int , b varchar ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 20: using PQexec
+[NO_PID]: ecpg_execute on line 20: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 20 Ok: CREATE TABLE
+[NO_PID]: ecpg_execute on line 20: OK: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 21: QUERY: insert into foo values ( 5 , 'abc' ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 21: query: insert into foo values ( 5 , 'abc' ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 21: using PQexec
+[NO_PID]: ecpg_execute on line 21: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 21 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 21: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 22: QUERY: insert into foo values ( 6 , 'def' ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 22: query: insert into foo values ( 6 , 'def' ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 22: using PQexec
+[NO_PID]: ecpg_execute on line 22: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 22 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 22: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 23: QUERY: insert into foo values ( 7 , 'ghi' ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 23: query: insert into foo values ( 7 , 'ghi' ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 23: using PQexec
+[NO_PID]: ecpg_execute on line 23: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 23 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 23: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 29: QUERY: copy foo to stdout with delimiter ',' with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 29: query: copy foo to stdout with delimiter ','; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 29: using PQexec
+[NO_PID]: ecpg_execute on line 29: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 29: Got PGRES_COPY_OUT
+[NO_PID]: ecpg_execute on line 29: COPY OUT data transfer in progress
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 29: Got PGRES_COMMAND_OK after PGRES_COPY_OUT
+[NO_PID]: ecpg_execute on line 29: got PGRES_COMMAND_OK after PGRES_COPY_OUT
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection regress1 closed.
+[NO_PID]: ecpg_finish: connection regress1 closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 19: QUERY: create table test ( a int , b text ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 19: query: create table test ( a int , b text ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 19: using PQexec
+[NO_PID]: ecpg_execute on line 19: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 19 Ok: CREATE TABLE
+[NO_PID]: ecpg_execute on line 19: OK: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 20: QUERY: insert into test values ( 29 , 'abcdef' ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 20: query: insert into test values ( 29 , 'abcdef' ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 20: using PQexec
+[NO_PID]: ecpg_execute on line 20: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 20 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 20: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 23: QUERY: insert into test values ( null , 'defined' ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 23: query: insert into test values ( null , 'defined' ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 23: using PQexec
+[NO_PID]: ecpg_execute on line 23: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 23 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 23: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 31: QUERY: insert into test values ( null , 'someothervar not defined' ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 31: query: insert into test values ( null , 'someothervar not defined' ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 31: using PQexec
+[NO_PID]: ecpg_execute on line 31: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 31 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 31: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 36: QUERY: select 1 , 29 :: text || '-' || 'abcdef' with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 36: query: select 1 , 29 :: text || '-' || 'abcdef' ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 36: using PQexec
+[NO_PID]: ecpg_execute on line 36: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 36: Correctly got 1 tuples with 2 fields
+[NO_PID]: ecpg_execute on line 36: correctly got 1 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 36: RESULT: 1 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 36: RESULT: 1 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 36: RESULT: 29-abcdef offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 36: RESULT: 29-abcdef offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 42: QUERY: insert into test values ( 29 , 'no string' ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 42: query: insert into test values ( 29 , 'no string' ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 42: using PQexec
+[NO_PID]: ecpg_execute on line 42: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 42 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 42: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 53: QUERY: set TIMEZONE to 'UTC' with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 53: query: set TIMEZONE to 'UTC'; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 53: using PQexec
+[NO_PID]: ecpg_execute on line 53: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 53 Ok: SET
+[NO_PID]: ecpg_execute on line 53: OK: SET
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection regress1 closed.
+[NO_PID]: ecpg_finish: connection regress1 closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 29: QUERY: create table test1 ( a int , b text ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 29: query: create table test1 ( a int , b text ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 29: using PQexec
+[NO_PID]: ecpg_execute on line 29: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 29 Ok: CREATE TABLE
+[NO_PID]: ecpg_execute on line 29: OK: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGprepare line 30: NAME: foo1 QUERY: INSERT INTO test1 VALUES ($1, $2)
+[NO_PID]: ECPGprepare on line 30: name foo1; query: "INSERT INTO test1 VALUES ($1, $2)"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGprepare line 31: NAME: Foo-1 QUERY: INSERT INTO test1 VALUES ($1, $2)
+[NO_PID]: ECPGprepare on line 31: name Foo-1; query: "INSERT INTO test1 VALUES ($1, $2)"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGprepare line 32: NAME: foo2 QUERY: SELECT * from test1 where a = $1 and b = $2
+[NO_PID]: ECPGprepare on line 32: name foo2; query: "SELECT * from test1 where a = $1 and b = $2"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGprepare line 33: NAME: foo3 QUERY: SELECT * from test1 where $1 = a
+[NO_PID]: ECPGprepare on line 33: name foo3; query: "SELECT * from test1 where $1 = a"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35: QUERY: INSERT INTO test1 VALUES ($1, $2) with 2 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 35: query: INSERT INTO test1 VALUES ($1, $2); with 2 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35: using PQexecPrepared for INSERT INTO test1 VALUES ($1, $2)
+[NO_PID]: ecpg_execute on line 35: using PQexecPrepared for "INSERT INTO test1 VALUES ($1, $2)"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 35: parameter 1 = 1
+[NO_PID]: free_params on line 35: parameter 1 = 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 35: parameter 2 = one
+[NO_PID]: free_params on line 35: parameter 2 = one
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 35: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 40: QUERY: INSERT INTO test1 VALUES ($1, $2) with 2 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 40: query: INSERT INTO test1 VALUES ($1, $2); with 2 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 40: using PQexecPrepared for INSERT INTO test1 VALUES ($1, $2)
+[NO_PID]: ecpg_execute on line 40: using PQexecPrepared for "INSERT INTO test1 VALUES ($1, $2)"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 40: parameter 1 = 2
+[NO_PID]: free_params on line 40: parameter 1 = 2
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 40: parameter 2 = null
+[NO_PID]: free_params on line 40: parameter 2 = null
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 40 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 40: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 45: QUERY: INSERT INTO test1 VALUES ($1, $2) with 2 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 45: query: INSERT INTO test1 VALUES ($1, $2); with 2 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 45: using PQexecPrepared for INSERT INTO test1 VALUES ($1, $2)
+[NO_PID]: ecpg_execute on line 45: using PQexecPrepared for "INSERT INTO test1 VALUES ($1, $2)"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 45: parameter 1 = 3
+[NO_PID]: free_params on line 45: parameter 1 = 3
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 45: parameter 2 = this is a long test
+[NO_PID]: free_params on line 45: parameter 2 = this is a long test
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 45 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 45: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGdeallocate line 47: NAME: Foo-1
+[NO_PID]: ECPGdeallocate on line 47: name Foo-1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 52: QUERY: SELECT * from test1 where a = $1 and b = $2 with 2 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 52: query: SELECT * from test1 where a = $1 and b = $2; with 2 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 52: using PQexecPrepared for SELECT * from test1 where a = $1 and b = $2
+[NO_PID]: ecpg_execute on line 52: using PQexecPrepared for "SELECT * from test1 where a = $1 and b = $2"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 52: parameter 1 = 1
+[NO_PID]: free_params on line 52: parameter 1 = 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 52: parameter 2 = one
+[NO_PID]: free_params on line 52: parameter 2 = one
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 52: Correctly got 1 tuples with 2 fields
+[NO_PID]: ecpg_execute on line 52: correctly got 1 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute putting result (1 tuples) into descriptor 'outdesc'
+[NO_PID]: ecpg_execute on line 52: putting result (1 tuples) into descriptor outdesc
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 54: RESULT: 1 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 54: RESULT: 1 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 58: QUERY: declare c1 cursor for SELECT * from test1 where a = $1 and b = $2 with 2 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 58: query: declare c1 cursor for SELECT * from test1 where a = $1 and b = $2; with 2 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 58: using PQexecParams
+[NO_PID]: ecpg_execute on line 58: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 58: parameter 1 = 1
+[NO_PID]: free_params on line 58: parameter 1 = 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 58: parameter 2 = one
+[NO_PID]: free_params on line 58: parameter 2 = one
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 58 Ok: DECLARE CURSOR
+[NO_PID]: ecpg_execute on line 58: OK: DECLARE CURSOR
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 60: QUERY: fetch next from c1 with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 60: query: fetch next from c1; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 60: using PQexec
+[NO_PID]: ecpg_execute on line 60: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 60: Correctly got 1 tuples with 2 fields
+[NO_PID]: ecpg_execute on line 60: correctly got 1 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 60: RESULT: 1 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 60: RESULT: 1 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 60: RESULT: one offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 60: RESULT: one offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 64: QUERY: close c1 with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 64: query: close c1; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 64: using PQexec
+[NO_PID]: ecpg_execute on line 64: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 64 Ok: CLOSE CURSOR
+[NO_PID]: ecpg_execute on line 64: OK: CLOSE CURSOR
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 70: QUERY: declare c2 cursor for SELECT * from test1 where $1 = a with 1 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 70: query: declare c2 cursor for SELECT * from test1 where $1 = a; with 1 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 70: using PQexecParams
+[NO_PID]: ecpg_execute on line 70: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 70: parameter 1 = 2
+[NO_PID]: free_params on line 70: parameter 1 = 2
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 70 Ok: DECLARE CURSOR
+[NO_PID]: ecpg_execute on line 70: OK: DECLARE CURSOR
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 72: QUERY: fetch next from c2 with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 72: query: fetch next from c2; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 72: using PQexec
+[NO_PID]: ecpg_execute on line 72: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 72: Correctly got 1 tuples with 2 fields
+[NO_PID]: ecpg_execute on line 72: correctly got 1 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 72: RESULT: 2 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 72: RESULT: 2 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 72: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 72: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 75: QUERY: close c2 with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 75: query: close c2; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 75: using PQexec
+[NO_PID]: ecpg_execute on line 75: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 75 Ok: CLOSE CURSOR
+[NO_PID]: ecpg_execute on line 75: OK: CLOSE CURSOR
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 77: QUERY: select * from test1 where a = 3 with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 77: query: select * from test1 where a = 3 ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 77: using PQexec
+[NO_PID]: ecpg_execute on line 77: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 77: Correctly got 1 tuples with 2 fields
+[NO_PID]: ecpg_execute on line 77: correctly got 1 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 77: RESULT: 3 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 77: RESULT: 3 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 77: RESULT: this is a long test offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 77: RESULT: this is a long test offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 80: QUERY: drop table test1 with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 80: query: drop table test1 ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 80: using PQexec
+[NO_PID]: ecpg_execute on line 80: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 80 Ok: DROP TABLE
+[NO_PID]: ecpg_execute on line 80: OK: DROP TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGdeallocate line 81: NAME: foo3
+[NO_PID]: ECPGdeallocate on line 81: name foo3
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGdeallocate line 81: NAME: foo2
+[NO_PID]: ECPGdeallocate on line 81: name foo2
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGdeallocate line 81: NAME: foo1
+[NO_PID]: ECPGdeallocate on line 81: name foo1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection regress1 closed.
+[NO_PID]: ecpg_finish: connection regress1 closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35: QUERY: set datestyle to mdy with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 35: query: set datestyle to mdy; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35: using PQexec
+[NO_PID]: ecpg_execute on line 35: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35 Ok: SET
+[NO_PID]: ecpg_execute on line 35: OK: SET
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 37: QUERY: create table test ( a serial , b numeric ( 12 , 3 ) , c varchar , d varchar ( 3 ) , e char ( 4 ) , f timestamptz , g boolean , h box , i inet ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 37: query: create table test ( a serial , b numeric ( 12 , 3 ) , c varchar , d varchar ( 3 ) , e char ( 4 ) , f timestamptz , g boolean , h box , i inet ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 37: using PQexec
+[NO_PID]: ecpg_execute on line 37: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 37 Ok: CREATE TABLE
+[NO_PID]: ecpg_execute on line 37: OK: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 38: QUERY: insert into test ( b , c , d , e , f , g , h , i ) values ( 23.456 , 'varchar' , 'v' , 'c' , '2003-03-03 12:33:07 PDT' , true , '(1,2,3,4)' , '2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128' ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 38: query: insert into test ( b , c , d , e , f , g , h , i ) values ( 23.456 , 'varchar' , 'v' , 'c' , '2003-03-03 12:33:07 PDT' , true , '(1,2,3,4)' , '2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128' ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 38: using PQexec
+[NO_PID]: ecpg_execute on line 38: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 38 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 38: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 39: QUERY: insert into test ( b , c , d , e , f , g , h , i ) values ( 2.446456 , null , 'v' , 'c' , '2003-03-03 12:33:07 PDT' , false , null , null ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 39: query: insert into test ( b , c , d , e , f , g , h , i ) values ( 2.446456 , null , 'v' , 'c' , '2003-03-03 12:33:07 PDT' , false , null , null ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 39: using PQexec
+[NO_PID]: ecpg_execute on line 39: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 39 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 39: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 42: QUERY: select a , b , c , d , e , f , g , h , i from test order by a with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 42: query: select a , b , c , d , e , f , g , h , i from test order by a ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 42: using PQexec
+[NO_PID]: ecpg_execute on line 42: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 42: Correctly got 2 tuples with 9 fields
+[NO_PID]: ecpg_execute on line 42: correctly got 2 tuples with 9 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute putting result (2 tuples) into descriptor 'mydesc'
+[NO_PID]: ecpg_execute on line 42: putting result (2 tuples) into descriptor mydesc
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_store_result: line 43: allocating memory for 2 tuples
+[NO_PID]: ecpg_store_result on line 43: allocating memory for 2 tuples
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 43: RESULT: 1 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 43: RESULT: 1 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 43: RESULT: 2 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 43: RESULT: 2 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 2
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_store_result: line 44: allocating memory for 2 tuples
+[NO_PID]: ecpg_store_result on line 44: allocating memory for 2 tuples
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 44: RESULT: 23.456 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 44: RESULT: 23.456 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 44: RESULT: 2.446 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 44: RESULT: 2.446 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 3
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_store_result: line 45: allocating memory for 2 tuples
+[NO_PID]: ecpg_store_result on line 45: allocating memory for 2 tuples
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 45: RESULT: varchar offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 45: RESULT: varchar offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 45: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 45: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 4
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_store_result: line 46: allocating memory for 2 tuples
+[NO_PID]: ecpg_store_result on line 46: allocating memory for 2 tuples
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 46: RESULT: v offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 46: RESULT: v offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 46: RESULT: v offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 46: RESULT: v offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 5
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_store_result: line 47: allocating memory for 2 tuples
+[NO_PID]: ecpg_store_result on line 47: allocating memory for 2 tuples
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 47: RESULT: c offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 47: RESULT: c offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 47: RESULT: c offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 47: RESULT: c offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 6
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_store_result: line 48: allocating memory for 2 tuples
+[NO_PID]: ecpg_store_result on line 48: allocating memory for 2 tuples
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 48: RESULT: Mon Mar 03 11:33:07 2003 PST offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 48: RESULT: Mon Mar 03 11:33:07 2003 PST offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 48: RESULT: Mon Mar 03 11:33:07 2003 PST offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 48: RESULT: Mon Mar 03 11:33:07 2003 PST offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 7
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_store_result: line 49: allocating memory for 2 tuples
+[NO_PID]: ecpg_store_result on line 49: allocating memory for 2 tuples
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 49: RESULT: t offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 49: RESULT: t offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 49: RESULT: f offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 49: RESULT: f offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 9
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_store_result: line 52: allocating memory for 2 tuples
+[NO_PID]: ecpg_store_result on line 52: allocating memory for 2 tuples
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 52: RESULT: 2001:4f8:3:ba:2e0:81ff:fe22:d1f1 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 52: RESULT: 2001:4f8:3:ba:2e0:81ff:fe22:d1f1 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 52: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 52: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection regress1 closed.
+[NO_PID]: ecpg_finish: connection regress1 closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 22: QUERY: set datestyle to postgres with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 22: query: set datestyle to postgres; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 22: using PQexec
+[NO_PID]: ecpg_execute on line 22: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 22 Ok: SET
+[NO_PID]: ecpg_execute on line 22: OK: SET
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 24: QUERY: create table test ( a int , b text ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 24: query: create table test ( a int , b text ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 24: using PQexec
+[NO_PID]: ecpg_execute on line 24: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 24 Ok: CREATE TABLE
+[NO_PID]: ecpg_execute on line 24: OK: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 25: QUERY: insert into test values ( 1 , 'one' ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 25: query: insert into test values ( 1 , 'one' ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 25: using PQexec
+[NO_PID]: ecpg_execute on line 25: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 25 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 25: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26: QUERY: insert into test values ( 2 , 'two' ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 26: query: insert into test values ( 2 , 'two' ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26: using PQexec
+[NO_PID]: ecpg_execute on line 26: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 26: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 27: QUERY: insert into test values ( null , 'three' ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 27: query: insert into test values ( null , 'three' ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 27: using PQexec
+[NO_PID]: ecpg_execute on line 27: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 27 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 27: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 28: QUERY: insert into test values ( 4 , 'four' ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 28: query: insert into test values ( 4 , 'four' ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 28: using PQexec
+[NO_PID]: ecpg_execute on line 28: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 28 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 28: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 29: QUERY: insert into test values ( 5 , null ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 29: query: insert into test values ( 5 , null ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 29: using PQexec
+[NO_PID]: ecpg_execute on line 29: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 29 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 29: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 30: QUERY: insert into test values ( null , null ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 30: query: insert into test values ( null , null ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 30: using PQexec
+[NO_PID]: ecpg_execute on line 30: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 30 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 30: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 33: QUERY: select * from test with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 33: query: select * from test ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 33: using PQexec
+[NO_PID]: ecpg_execute on line 33: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 33: Correctly got 6 tuples with 2 fields
+[NO_PID]: ecpg_execute on line 33: correctly got 6 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute putting result (6 tuples) into descriptor 'mydesc'
+[NO_PID]: ecpg_execute on line 33: putting result (6 tuples) into descriptor mydesc
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGget_desc_header: found 2 attributes.
+[NO_PID]: ECPGget_desc_header: found 2 attributes
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_store_result: line 35: allocating memory for 6 tuples
+[NO_PID]: ecpg_store_result on line 35: allocating memory for 6 tuples
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 35: RESULT: 1 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 35: RESULT: 1 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 35: RESULT: 2 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 35: RESULT: 2 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 35: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 35: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 35: RESULT: 4 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 35: RESULT: 4 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 35: RESULT: 5 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 35: RESULT: 5 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 35: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 35: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 2
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_store_result: line 36: allocating memory for 6 tuples
+[NO_PID]: ecpg_store_result on line 36: allocating memory for 6 tuples
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 36: RESULT: one offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 36: RESULT: one offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 36: RESULT: two offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 36: RESULT: two offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 36: RESULT: three offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 36: RESULT: three offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 36: RESULT: four offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 36: RESULT: four offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 36: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 36: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 36: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 36: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 52 action = rollback connection = regress1
+[NO_PID]: ECPGtrans on line 52: action "rollback"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection regress1 closed.
+[NO_PID]: ecpg_finish: connection regress1 closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 49: QUERY: set datestyle to german with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 49: query: set datestyle to german; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 49: using PQexec
+[NO_PID]: ecpg_execute on line 49: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 49 Ok: SET
+[NO_PID]: ecpg_execute on line 49: OK: SET
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 51: QUERY: create table dyntest ( name char ( 14 ) , d float8 , i int , bignumber int8 , b boolean , comment text , day date ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 51: query: create table dyntest ( name char ( 14 ) , d float8 , i int , bignumber int8 , b boolean , comment text , day date ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 51: using PQexec
+[NO_PID]: ecpg_execute on line 51: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 51 Ok: CREATE TABLE
+[NO_PID]: ecpg_execute on line 51: OK: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 54: QUERY: insert into dyntest values ( 'first entry' , 14.7 , 14 , 123045607890 , true , 'The world''s most advanced open source database.' , '1987-07-14' ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 54: query: insert into dyntest values ( 'first entry' , 14.7 , 14 , 123045607890 , true , 'The world''s most advanced open source database.' , '1987-07-14' ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 54: using PQexec
+[NO_PID]: ecpg_execute on line 54: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 54 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 54: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 55: QUERY: insert into dyntest values ( 'second entry' , 1407.87 , 1407 , 987065403210 , false , 'The elephant never forgets.' , '1999-11-5' ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 55: query: insert into dyntest values ( 'second entry' , 1407.87 , 1407 , 987065403210 , false , 'The elephant never forgets.' , '1999-11-5' ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 55: using PQexec
+[NO_PID]: ecpg_execute on line 55: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 55 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 55: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGprepare line 57: NAME: myquery QUERY: select * from dyntest
+[NO_PID]: ECPGprepare on line 57: name myquery; query: "select * from dyntest"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 60: QUERY: declare MYCURS cursor for select * from dyntest with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 60: query: declare MYCURS cursor for select * from dyntest; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 60: using PQexec
+[NO_PID]: ecpg_execute on line 60: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 60 Ok: DECLARE CURSOR
+[NO_PID]: ecpg_execute on line 60: OK: DECLARE CURSOR
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 64: QUERY: fetch in MYCURS with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 64: query: fetch in MYCURS; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 64: using PQexec
+[NO_PID]: ecpg_execute on line 64: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 64: Correctly got 1 tuples with 7 fields
+[NO_PID]: ecpg_execute on line 64: correctly got 1 tuples with 7 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute putting result (1 tuples) into descriptor 'MYDESC'
+[NO_PID]: ecpg_execute on line 64: putting result (1 tuples) into descriptor MYDESC
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGget_desc_header: found 7 attributes.
+[NO_PID]: ECPGget_desc_header: found 7 attributes
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 186: RESULT: first entry offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 186: RESULT: first entry offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 2
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 2
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 175: RESULT: 14.7 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 175: RESULT: 14.7 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 3
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 3
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 171: RESULT: 14 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 171: RESULT: 14 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 4
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 4
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 190: RESULT: 123045607890 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 190: RESULT: 123045607890 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 5
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 5
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 166: RESULT: t offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 166: RESULT: t offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 6
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 6
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 186: RESULT: The world's most advanced open source database. offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 186: RESULT: The world's most advanced open source database. offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 7
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: TYPE = 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 179: RESULT: 14.07.1987 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 179: RESULT: 14.07.1987 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 64: QUERY: fetch in MYCURS with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 64: query: fetch in MYCURS; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 64: using PQexec
+[NO_PID]: ecpg_execute on line 64: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 64: Correctly got 1 tuples with 7 fields
+[NO_PID]: ecpg_execute on line 64: correctly got 1 tuples with 7 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute putting result (1 tuples) into descriptor 'MYDESC'
+[NO_PID]: ecpg_execute on line 64: putting result (1 tuples) into descriptor MYDESC
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGget_desc_header: found 7 attributes.
+[NO_PID]: ECPGget_desc_header: found 7 attributes
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 1
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 186: RESULT: second entry offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 186: RESULT: second entry offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 2
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 2
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 175: RESULT: 1407.87 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 175: RESULT: 1407.87 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 3
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 3
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 171: RESULT: 1407 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 171: RESULT: 1407 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 4
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 4
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 190: RESULT: 987065403210 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 190: RESULT: 987065403210 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 5
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 5
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 166: RESULT: f offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 166: RESULT: f offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 6
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 6
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 186: RESULT: The elephant never forgets. offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 186: RESULT: The elephant never forgets. offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: reading items for tuple 7
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGget_desc: TYPE = 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 179: RESULT: 05.11.1999 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 179: RESULT: 05.11.1999 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 64: QUERY: fetch in MYCURS with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 64: query: fetch in MYCURS; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 64: using PQexec
+[NO_PID]: ecpg_execute on line 64: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 64: Correctly got 0 tuples with 7 fields
+[NO_PID]: ecpg_execute on line 64: correctly got 0 tuples with 7 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: raising sqlcode 100 in line 64, 'No data found in line 64.'.
+[NO_PID]: raising sqlcode 100 on line 64: no data found on line 64
[NO_PID]: sqlca: code: 100, state: 02000
-[NO_PID]: ecpg_execute line 197: QUERY: close MYCURS with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 197: query: close MYCURS; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 197: using PQexec
+[NO_PID]: ecpg_execute on line 197: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 197 Ok: CLOSE CURSOR
+[NO_PID]: ecpg_execute on line 197: OK: CLOSE CURSOR
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 25: QUERY: create table test ( name char ( 8 ) , amount int , letter char ( 1 ) ) with 0 parameter on connection main
+[NO_PID]: ecpg_execute on line 25: query: create table test ( name char ( 8 ) , amount int , letter char ( 1 ) ) ; with 0 parameter(s) on connection main
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 25: using PQexec
+[NO_PID]: ecpg_execute on line 25: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 25 Ok: CREATE TABLE
+[NO_PID]: ecpg_execute on line 25: OK: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 26 action = commit connection = main
+[NO_PID]: ECPGtrans on line 26: action "commit"; connection "main"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 29: QUERY: insert into test (name, amount, letter) values ('db: ''r1''', 1, 'f') with 0 parameter on connection main
+[NO_PID]: ecpg_execute on line 29: query: insert into test (name, amount, letter) values ('db: ''r1''', 1, 'f'); with 0 parameter(s) on connection main
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 29: using PQexec
+[NO_PID]: ecpg_execute on line 29: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 29 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 29: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 32: QUERY: insert into test (name, amount, letter) values ('db: ''r1''', 2, 't') with 0 parameter on connection main
+[NO_PID]: ecpg_execute on line 32: query: insert into test (name, amount, letter) values ('db: ''r1''', 2, 't'); with 0 parameter(s) on connection main
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 32: using PQexec
+[NO_PID]: ecpg_execute on line 32: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 32 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 32: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35: QUERY: insert into test (name, amount, letter) select name, amount+10, letter from test with 0 parameter on connection main
+[NO_PID]: ecpg_execute on line 35: query: insert into test (name, amount, letter) select name, amount+10, letter from test; with 0 parameter(s) on connection main
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35: using PQexec
+[NO_PID]: ecpg_execute on line 35: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35 Ok: INSERT 0 2
+[NO_PID]: ecpg_execute on line 35: OK: INSERT 0 2
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGprepare line 40: NAME: i QUERY: insert into test (name, amount, letter) select name, amount+$1, letter from test
+[NO_PID]: ECPGprepare on line 40: name i; query: "insert into test (name, amount, letter) select name, amount+$1, letter from test"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 41: QUERY: insert into test (name, amount, letter) select name, amount+$1, letter from test with 1 parameter on connection main
+[NO_PID]: ecpg_execute on line 41: query: insert into test (name, amount, letter) select name, amount+$1, letter from test; with 1 parameter(s) on connection main
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 41: using PQexecPrepared for insert into test (name, amount, letter) select name, amount+$1, letter from test
+[NO_PID]: ecpg_execute on line 41: using PQexecPrepared for "insert into test (name, amount, letter) select name, amount+$1, letter from test"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 41: parameter 1 = 100
+[NO_PID]: free_params on line 41: parameter 1 = 100
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 41 Ok: INSERT 0 4
+[NO_PID]: ecpg_execute on line 41: OK: INSERT 0 4
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 45 action = commit connection = main
+[NO_PID]: ECPGtrans on line 45: action "commit"; connection "main"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGprepare line 49: NAME: f QUERY: select * from test
+[NO_PID]: ECPGprepare on line 49: name f; query: "select * from test"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 52: QUERY: declare CUR cursor for select * from test with 0 parameter on connection main
+[NO_PID]: ecpg_execute on line 52: query: declare CUR cursor for select * from test; with 0 parameter(s) on connection main
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 52: using PQexec
+[NO_PID]: ecpg_execute on line 52: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 52 Ok: DECLARE CURSOR
+[NO_PID]: ecpg_execute on line 52: OK: DECLARE CURSOR
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 53: QUERY: fetch 8 in CUR with 0 parameter on connection main
+[NO_PID]: ecpg_execute on line 53: query: fetch 8 in CUR; with 0 parameter(s) on connection main
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 53: using PQexec
+[NO_PID]: ecpg_execute on line 53: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 53: Correctly got 8 tuples with 3 fields
+[NO_PID]: ecpg_execute on line 53: correctly got 8 tuples with 3 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: db: 'r1' offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: db: 'r1' offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: db: 'r1' offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: db: 'r1' offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: db: 'r1' offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: db: 'r1' offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: db: 'r1' offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: db: 'r1' offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: db: 'r1' offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: db: 'r1' offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: db: 'r1' offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: db: 'r1' offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: db: 'r1' offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: db: 'r1' offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: db: 'r1' offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: db: 'r1' offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: 1 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: 1 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: 2 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: 2 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: 11 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: 11 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: 12 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: 12 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: 101 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: 101 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: 102 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: 102 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: 111 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: 111 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: 112 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: 112 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: f offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: f offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: t offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: t offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: f offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: f offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: t offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: t offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: f offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: f offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: t offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: t offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: f offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: f offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: t offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: t offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 66: QUERY: close CUR with 0 parameter on connection main
+[NO_PID]: ecpg_execute on line 66: query: close CUR; with 0 parameter(s) on connection main
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 66: using PQexec
+[NO_PID]: ecpg_execute on line 66: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 66 Ok: CLOSE CURSOR
+[NO_PID]: ecpg_execute on line 66: OK: CLOSE CURSOR
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGdeallocate line 67: NAME: f
+[NO_PID]: ECPGdeallocate on line 67: name f
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGprepare line 71: NAME: f QUERY: select * from test where amount = $1
+[NO_PID]: ECPGprepare on line 71: name f; query: "select * from test where amount = $1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 74: QUERY: declare CUR2 cursor for select * from test where amount = $1 with 1 parameter on connection main
+[NO_PID]: ecpg_execute on line 74: query: declare CUR2 cursor for select * from test where amount = $1; with 1 parameter(s) on connection main
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 74: using PQexecParams
+[NO_PID]: ecpg_execute on line 74: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 74: parameter 1 = 1
+[NO_PID]: free_params on line 74: parameter 1 = 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 74 Ok: DECLARE CURSOR
+[NO_PID]: ecpg_execute on line 74: OK: DECLARE CURSOR
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 75: QUERY: fetch in CUR2 with 0 parameter on connection main
+[NO_PID]: ecpg_execute on line 75: query: fetch in CUR2; with 0 parameter(s) on connection main
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 75: using PQexec
+[NO_PID]: ecpg_execute on line 75: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 75: Correctly got 1 tuples with 3 fields
+[NO_PID]: ecpg_execute on line 75: correctly got 1 tuples with 3 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 75: RESULT: db: 'r1' offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 75: RESULT: db: 'r1' offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 75: RESULT: 1 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 75: RESULT: 1 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 75: RESULT: f offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 75: RESULT: f offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 88: QUERY: close CUR2 with 0 parameter on connection main
+[NO_PID]: ecpg_execute on line 88: query: close CUR2; with 0 parameter(s) on connection main
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 88: using PQexec
+[NO_PID]: ecpg_execute on line 88: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 88 Ok: CLOSE CURSOR
+[NO_PID]: ecpg_execute on line 88: OK: CLOSE CURSOR
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGdeallocate line 89: NAME: f
+[NO_PID]: ECPGdeallocate on line 89: name f
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGprepare line 93: NAME: f QUERY: select * from test where amount = $1
+[NO_PID]: ECPGprepare on line 93: name f; query: "select * from test where amount = $1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 94: QUERY: select * from test where amount = $1 with 1 parameter on connection main
+[NO_PID]: ecpg_execute on line 94: query: select * from test where amount = $1; with 1 parameter(s) on connection main
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 94: using PQexecPrepared for select * from test where amount = $1
+[NO_PID]: ecpg_execute on line 94: using PQexecPrepared for "select * from test where amount = $1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 94: parameter 1 = 2
+[NO_PID]: free_params on line 94: parameter 1 = 2
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 94: Correctly got 1 tuples with 3 fields
+[NO_PID]: ecpg_execute on line 94: correctly got 1 tuples with 3 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 94: RESULT: db: 'r1' offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 94: RESULT: db: 'r1' offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 94: RESULT: 2 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 94: RESULT: 2 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 94: RESULT: t offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 94: RESULT: t offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGdeallocate line 107: NAME: f
+[NO_PID]: ECPGdeallocate on line 107: name f
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 108: QUERY: drop table test with 0 parameter on connection main
+[NO_PID]: ecpg_execute on line 108: query: drop table test ; with 0 parameter(s) on connection main
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 108: using PQexec
+[NO_PID]: ecpg_execute on line 108: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 108 Ok: DROP TABLE
+[NO_PID]: ecpg_execute on line 108: OK: DROP TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 109 action = commit connection = main
+[NO_PID]: ECPGtrans on line 109: action "commit"; connection "main"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGdeallocate line 0: NAME: i
+[NO_PID]: ECPGdeallocate on line 0: name i
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection main closed.
+[NO_PID]: ecpg_finish: connection main closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 19: QUERY: create table My_Table ( Item1 int , Item2 text ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 19: query: create table My_Table ( Item1 int , Item2 text ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 19: using PQexec
+[NO_PID]: ecpg_execute on line 19: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 19 Ok: CREATE TABLE
+[NO_PID]: ecpg_execute on line 19: OK: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 21: QUERY: insert into My_Table values ( 1 , 'text1' ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 21: query: insert into My_Table values ( 1 , 'text1' ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 21: using PQexec
+[NO_PID]: ecpg_execute on line 21: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 21 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 21: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 22: QUERY: insert into My_Table values ( 2 , 'text2' ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 22: query: insert into My_Table values ( 2 , 'text2' ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 22: using PQexec
+[NO_PID]: ecpg_execute on line 22: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 22 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 22: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 23: QUERY: insert into My_Table values ( 3 , 'text3' ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 23: query: insert into My_Table values ( 3 , 'text3' ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 23: using PQexec
+[NO_PID]: ecpg_execute on line 23: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 23 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 23: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 24: QUERY: insert into My_Table values ( 4 , 'text4' ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 24: query: insert into My_Table values ( 4 , 'text4' ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 24: using PQexec
+[NO_PID]: ecpg_execute on line 24: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 24 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 24: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 28: QUERY: declare C cursor for select * from My_Table with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 28: query: declare C cursor for select * from My_Table ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 28: using PQexec
+[NO_PID]: ecpg_execute on line 28: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 28 Ok: DECLARE CURSOR
+[NO_PID]: ecpg_execute on line 28: OK: DECLARE CURSOR
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 32: QUERY: fetch 1 in C with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 32: query: fetch 1 in C; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 32: using PQexec
+[NO_PID]: ecpg_execute on line 32: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 32: Correctly got 1 tuples with 2 fields
+[NO_PID]: ecpg_execute on line 32: correctly got 1 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 32: RESULT: 1 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 32: RESULT: 1 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 32: RESULT: text1 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 32: RESULT: text1 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 32: QUERY: fetch 1 in C with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 32: query: fetch 1 in C; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 32: using PQexec
+[NO_PID]: ecpg_execute on line 32: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 32: Correctly got 1 tuples with 2 fields
+[NO_PID]: ecpg_execute on line 32: correctly got 1 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 32: RESULT: 2 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 32: RESULT: 2 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 32: RESULT: text2 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 32: RESULT: text2 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 32: QUERY: fetch 1 in C with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 32: query: fetch 1 in C; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 32: using PQexec
+[NO_PID]: ecpg_execute on line 32: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 32: Correctly got 1 tuples with 2 fields
+[NO_PID]: ecpg_execute on line 32: correctly got 1 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 32: RESULT: 3 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 32: RESULT: 3 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 32: RESULT: text3 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 32: RESULT: text3 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 32: QUERY: fetch 1 in C with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 32: query: fetch 1 in C; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 32: using PQexec
+[NO_PID]: ecpg_execute on line 32: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 32: Correctly got 1 tuples with 2 fields
+[NO_PID]: ecpg_execute on line 32: correctly got 1 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 32: RESULT: 4 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 32: RESULT: 4 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 32: RESULT: text4 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 32: RESULT: text4 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 32: QUERY: fetch 1 in C with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 32: query: fetch 1 in C; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 32: using PQexec
+[NO_PID]: ecpg_execute on line 32: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 32: Correctly got 0 tuples with 2 fields
+[NO_PID]: ecpg_execute on line 32: correctly got 0 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: raising sqlcode 100 in line 32, 'No data found in line 32.'.
+[NO_PID]: raising sqlcode 100 on line 32: no data found on line 32
[NO_PID]: sqlca: code: 100, state: 02000
-[NO_PID]: ecpg_execute line 37: QUERY: move backward 2 in C with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 37: query: move backward 2 in C; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 37: using PQexec
+[NO_PID]: ecpg_execute on line 37: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 37 Ok: MOVE 2
+[NO_PID]: ecpg_execute on line 37: OK: MOVE 2
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 39: QUERY: fetch 1 in C with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 39: query: fetch 1 in C; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 39: using PQexec
+[NO_PID]: ecpg_execute on line 39: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 39: Correctly got 1 tuples with 2 fields
+[NO_PID]: ecpg_execute on line 39: correctly got 1 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 39: RESULT: 4 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 39: RESULT: 4 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 39: RESULT: text4 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 39: RESULT: text4 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 42: QUERY: close C with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 42: query: close C; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 42: using PQexec
+[NO_PID]: ecpg_execute on line 42: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 42 Ok: CLOSE CURSOR
+[NO_PID]: ecpg_execute on line 42: OK: CLOSE CURSOR
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 44: QUERY: drop table My_Table with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 44: query: drop table My_Table ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 44: using PQexec
+[NO_PID]: ecpg_execute on line 44: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 44 Ok: DROP TABLE
+[NO_PID]: ecpg_execute on line 44: OK: DROP TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection regress1 closed.
+[NO_PID]: ecpg_finish: connection regress1 closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGsetcommit line 13 action = on connection = regress1
+[NO_PID]: ECPGsetcommit on line 13: action "on"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 17: QUERY: create table My_Table ( Item1 int , Item2 text ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 17: query: create table My_Table ( Item1 int , Item2 text ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 17: using PQexec
+[NO_PID]: ecpg_execute on line 17: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 17 Ok: CREATE TABLE
+[NO_PID]: ecpg_execute on line 17: OK: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 18: QUERY: create table Log ( name text , w text ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 18: query: create table Log ( name text , w text ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 18: using PQexec
+[NO_PID]: ecpg_execute on line 18: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 18 Ok: CREATE TABLE
+[NO_PID]: ecpg_execute on line 18: OK: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 20: QUERY: create function My_Table_Check () returns trigger as $test$ BEGIN INSERT INTO Log VALUES(TG_NAME, TG_WHEN); RETURN NEW; END; $test$ language plpgsql with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 20: query: create function My_Table_Check () returns trigger as $test$ BEGIN INSERT INTO Log VALUES(TG_NAME, TG_WHEN); RETURN NEW; END; $test$ language plpgsql; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 20: using PQexec
+[NO_PID]: ecpg_execute on line 20: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 20 Ok: CREATE FUNCTION
+[NO_PID]: ecpg_execute on line 20: OK: CREATE FUNCTION
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 28: QUERY: create trigger My_Table_Check_Trigger before insert on My_Table for each row execute procedure My_Table_Check ( ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 28: query: create trigger My_Table_Check_Trigger before insert on My_Table for each row execute procedure My_Table_Check ( ); with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 28: using PQexec
+[NO_PID]: ecpg_execute on line 28: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 28 Ok: CREATE TRIGGER
+[NO_PID]: ecpg_execute on line 28: OK: CREATE TRIGGER
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 34: QUERY: insert into My_Table values ( 1234 , 'Some random text' ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 34: query: insert into My_Table values ( 1234 , 'Some random text' ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 34: using PQexec
+[NO_PID]: ecpg_execute on line 34: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 34 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 34: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35: QUERY: insert into My_Table values ( 5678 , 'The Quick Brown' ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 35: query: insert into My_Table values ( 5678 , 'The Quick Brown' ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35: using PQexec
+[NO_PID]: ecpg_execute on line 35: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 35: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 36: QUERY: select name from Log limit 1 with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 36: query: select name from Log limit 1 ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 36: using PQexec
+[NO_PID]: ecpg_execute on line 36: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 36: Correctly got 1 tuples with 1 fields
+[NO_PID]: ecpg_execute on line 36: correctly got 1 tuples with 1 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 36: RESULT: my_table_check_trigger offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 36: RESULT: my_table_check_trigger offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 39: QUERY: drop trigger My_Table_Check_Trigger on My_Table with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 39: query: drop trigger My_Table_Check_Trigger on My_Table ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 39: using PQexec
+[NO_PID]: ecpg_execute on line 39: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 39 Ok: DROP TRIGGER
+[NO_PID]: ecpg_execute on line 39: OK: DROP TRIGGER
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 40: QUERY: drop function My_Table_Check () with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 40: query: drop function My_Table_Check () ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 40: using PQexec
+[NO_PID]: ecpg_execute on line 40: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 40 Ok: DROP FUNCTION
+[NO_PID]: ecpg_execute on line 40: OK: DROP FUNCTION
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 41: QUERY: drop table Log with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 41: query: drop table Log ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 41: using PQexec
+[NO_PID]: ecpg_execute on line 41: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 41 Ok: DROP TABLE
+[NO_PID]: ecpg_execute on line 41: OK: DROP TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 42: QUERY: drop table My_Table with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 42: query: drop table My_Table ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 42: using PQexec
+[NO_PID]: ecpg_execute on line 42: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 42 Ok: DROP TABLE
+[NO_PID]: ecpg_execute on line 42: OK: DROP TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection regress1 closed.
+[NO_PID]: ecpg_finish: connection regress1 closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGsetcommit line 17 action = off connection = regress1
+[NO_PID]: ECPGsetcommit on line 17: action "off"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 19: QUERY: create table indicator_test ( "id" int primary key , "str" text not null , val int null ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 19: query: create table indicator_test ( "id" int primary key , "str" text not null , val int null ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 19: using PQexec
+[NO_PID]: ecpg_execute on line 19: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 19 Ok: CREATE TABLE
+[NO_PID]: ecpg_execute on line 19: OK: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 23 action = commit connection = regress1
+[NO_PID]: ECPGtrans on line 23: action "commit"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 25: QUERY: insert into indicator_test ( id , str , val ) values ( 1 , 'Hello' , 0 ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 25: query: insert into indicator_test ( id , str , val ) values ( 1 , 'Hello' , 0 ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 25: using PQexec
+[NO_PID]: ecpg_execute on line 25: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 25 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 25: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 28: QUERY: insert into indicator_test ( id , str , val ) values ( 2 , 'Hi there' , $1 ) with 1 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 28: query: insert into indicator_test ( id , str , val ) values ( 2 , 'Hi there' , $1 ) ; with 1 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 28: using PQexecParams
+[NO_PID]: ecpg_execute on line 28: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 28: parameter 1 = null
+[NO_PID]: free_params on line 28: parameter 1 = null
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 28 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 28: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 30: QUERY: insert into indicator_test ( id , str , val ) values ( 3 , 'Good evening' , $1 ) with 1 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 30: query: insert into indicator_test ( id , str , val ) values ( 3 , 'Good evening' , $1 ) ; with 1 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 30: using PQexecParams
+[NO_PID]: ecpg_execute on line 30: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 30: parameter 1 = 5
+[NO_PID]: free_params on line 30: parameter 1 = 5
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 30 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 30: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 31 action = commit connection = regress1
+[NO_PID]: ECPGtrans on line 31: action "commit"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 34: QUERY: select val from indicator_test where id = 1 with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 34: query: select val from indicator_test where id = 1 ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 34: using PQexec
+[NO_PID]: ecpg_execute on line 34: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 34: Correctly got 1 tuples with 1 fields
+[NO_PID]: ecpg_execute on line 34: correctly got 1 tuples with 1 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 34: RESULT: 0 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 34: RESULT: 0 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35: QUERY: select val from indicator_test where id = 2 with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 35: query: select val from indicator_test where id = 2 ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35: using PQexec
+[NO_PID]: ecpg_execute on line 35: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35: Correctly got 1 tuples with 1 fields
+[NO_PID]: ecpg_execute on line 35: correctly got 1 tuples with 1 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 35: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 35: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 37: QUERY: select val from indicator_test where id = 3 with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 37: query: select val from indicator_test where id = 3 ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 37: using PQexec
+[NO_PID]: ecpg_execute on line 37: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 37: Correctly got 1 tuples with 1 fields
+[NO_PID]: ecpg_execute on line 37: correctly got 1 tuples with 1 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 37: RESULT: 5 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 37: RESULT: 5 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 42: QUERY: update indicator_test set val = $1 where id = 1 with 1 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 42: query: update indicator_test set val = $1 where id = 1 ; with 1 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 42: using PQexecParams
+[NO_PID]: ecpg_execute on line 42: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 42: parameter 1 = null
+[NO_PID]: free_params on line 42: parameter 1 = null
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 42 Ok: UPDATE 1
+[NO_PID]: ecpg_execute on line 42: OK: UPDATE 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 43: QUERY: select val from indicator_test where id = 1 with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 43: query: select val from indicator_test where id = 1 ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 43: using PQexec
+[NO_PID]: ecpg_execute on line 43: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 43: Correctly got 1 tuples with 1 fields
+[NO_PID]: ecpg_execute on line 43: correctly got 1 tuples with 1 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 43: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 43: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 46: QUERY: drop table indicator_test with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 46: query: drop table indicator_test ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 46: using PQexec
+[NO_PID]: ecpg_execute on line 46: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 46 Ok: DROP TABLE
+[NO_PID]: ecpg_execute on line 46: OK: DROP TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 47 action = commit connection = regress1
+[NO_PID]: ECPGtrans on line 47: action "commit"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection regress1 closed.
+[NO_PID]: ecpg_finish: connection regress1 closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 18: QUERY: create table insupd_test ( a int , b int ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 18: query: create table insupd_test ( a int , b int ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 18: using PQexec
+[NO_PID]: ecpg_execute on line 18: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 18 Ok: CREATE TABLE
+[NO_PID]: ecpg_execute on line 18: OK: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 20: QUERY: insert into insupd_test ( a , b ) values ( 1 , 1 ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 20: query: insert into insupd_test ( a , b ) values ( 1 , 1 ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 20: using PQexec
+[NO_PID]: ecpg_execute on line 20: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 20 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 20: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 21: QUERY: insert into insupd_test ( a , b ) values ( 2 , 2 ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 21: query: insert into insupd_test ( a , b ) values ( 2 , 2 ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 21: using PQexec
+[NO_PID]: ecpg_execute on line 21: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 21 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 21: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 22: QUERY: insert into insupd_test ( a , b ) values ( 3 , 3 ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 22: query: insert into insupd_test ( a , b ) values ( 3 , 3 ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 22: using PQexec
+[NO_PID]: ecpg_execute on line 22: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 22 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 22: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 24: QUERY: update insupd_test set a = a + 1 with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 24: query: update insupd_test set a = a + 1 ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 24: using PQexec
+[NO_PID]: ecpg_execute on line 24: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 24 Ok: UPDATE 3
+[NO_PID]: ecpg_execute on line 24: OK: UPDATE 3
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 25: QUERY: update insupd_test set ( a , b )= ( 5 , 5 ) where a = 4 with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 25: query: update insupd_test set ( a , b )= ( 5 , 5 ) where a = 4 ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 25: using PQexec
+[NO_PID]: ecpg_execute on line 25: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 25 Ok: UPDATE 1
+[NO_PID]: ecpg_execute on line 25: OK: UPDATE 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26: QUERY: update insupd_test set a = 4 where a = 3 with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 26: query: update insupd_test set a = 4 where a = 3 ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26: using PQexec
+[NO_PID]: ecpg_execute on line 26: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26 Ok: UPDATE 1
+[NO_PID]: ecpg_execute on line 26: OK: UPDATE 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 28: QUERY: select a , b from insupd_test order by a with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 28: query: select a , b from insupd_test order by a ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 28: using PQexec
+[NO_PID]: ecpg_execute on line 28: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 28: Correctly got 3 tuples with 2 fields
+[NO_PID]: ecpg_execute on line 28: correctly got 3 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 28: RESULT: 2 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 28: RESULT: 2 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 28: RESULT: 4 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 28: RESULT: 4 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 28: RESULT: 5 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 28: RESULT: 5 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 28: RESULT: 1 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 28: RESULT: 1 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 28: RESULT: 2 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 28: RESULT: 2 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 28: RESULT: 5 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 28: RESULT: 5 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection regress1 closed.
+[NO_PID]: ecpg_finish: connection regress1 closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 25: QUERY: create table test ( name char ( 8 ) , amount int , letter char ( 1 ) ) with 0 parameter on connection main
+[NO_PID]: ecpg_execute on line 25: query: create table test ( name char ( 8 ) , amount int , letter char ( 1 ) ) ; with 0 parameter(s) on connection main
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 25: using PQexec
+[NO_PID]: ecpg_execute on line 25: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 25 Ok: CREATE TABLE
+[NO_PID]: ecpg_execute on line 25: OK: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 26 action = commit connection = main
+[NO_PID]: ECPGtrans on line 26: action "commit"; connection "main"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 29: QUERY: insert into test (name, amount, letter) values ('db: ''r1''', 1, 'f') with 0 parameter on connection main
+[NO_PID]: ecpg_execute on line 29: query: insert into test (name, amount, letter) values ('db: ''r1''', 1, 'f'); with 0 parameter(s) on connection main
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 29: using PQexec
+[NO_PID]: ecpg_execute on line 29: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 29 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 29: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 32: QUERY: insert into test (name, amount, letter) values ('db: ''r1''', 2, 't') with 0 parameter on connection main
+[NO_PID]: ecpg_execute on line 32: query: insert into test (name, amount, letter) values ('db: ''r1''', 2, 't'); with 0 parameter(s) on connection main
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 32: using PQexec
+[NO_PID]: ecpg_execute on line 32: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 32 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 32: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35: QUERY: insert into test (name, amount, letter) select name, amount+10, letter from test with 0 parameter on connection main
+[NO_PID]: ecpg_execute on line 35: query: insert into test (name, amount, letter) select name, amount+10, letter from test; with 0 parameter(s) on connection main
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35: using PQexec
+[NO_PID]: ecpg_execute on line 35: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35 Ok: INSERT 0 2
+[NO_PID]: ecpg_execute on line 35: OK: INSERT 0 2
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGprepare line 40: NAME: i QUERY: insert into test (name, amount, letter) select name, amount+$1, letter from test
+[NO_PID]: ECPGprepare on line 40: name i; query: "insert into test (name, amount, letter) select name, amount+$1, letter from test"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 41: QUERY: insert into test (name, amount, letter) select name, amount+$1, letter from test with 1 parameter on connection main
+[NO_PID]: ecpg_execute on line 41: query: insert into test (name, amount, letter) select name, amount+$1, letter from test; with 1 parameter(s) on connection main
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 41: using PQexecPrepared for insert into test (name, amount, letter) select name, amount+$1, letter from test
+[NO_PID]: ecpg_execute on line 41: using PQexecPrepared for "insert into test (name, amount, letter) select name, amount+$1, letter from test"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 41: parameter 1 = 100
+[NO_PID]: free_params on line 41: parameter 1 = 100
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 41 Ok: INSERT 0 4
+[NO_PID]: ecpg_execute on line 41: OK: INSERT 0 4
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 45 action = commit connection = main
+[NO_PID]: ECPGtrans on line 45: action "commit"; connection "main"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGprepare line 49: NAME: f QUERY: select * from test
+[NO_PID]: ECPGprepare on line 49: name f; query: "select * from test"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 52: QUERY: declare CUR cursor for select * from test with 0 parameter on connection main
+[NO_PID]: ecpg_execute on line 52: query: declare CUR cursor for select * from test; with 0 parameter(s) on connection main
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 52: using PQexec
+[NO_PID]: ecpg_execute on line 52: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 52 Ok: DECLARE CURSOR
+[NO_PID]: ecpg_execute on line 52: OK: DECLARE CURSOR
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 53: QUERY: fetch 8 in CUR with 0 parameter on connection main
+[NO_PID]: ecpg_execute on line 53: query: fetch 8 in CUR; with 0 parameter(s) on connection main
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 53: using PQexec
+[NO_PID]: ecpg_execute on line 53: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 53: Correctly got 8 tuples with 3 fields
+[NO_PID]: ecpg_execute on line 53: correctly got 8 tuples with 3 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: db: 'r1' offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: db: 'r1' offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: db: 'r1' offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: db: 'r1' offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: db: 'r1' offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: db: 'r1' offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: db: 'r1' offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: db: 'r1' offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: db: 'r1' offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: db: 'r1' offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: db: 'r1' offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: db: 'r1' offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: db: 'r1' offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: db: 'r1' offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: db: 'r1' offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: db: 'r1' offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: 1 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: 1 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: 2 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: 2 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: 11 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: 11 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: 12 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: 12 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: 101 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: 101 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: 102 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: 102 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: 111 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: 111 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: 112 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: 112 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: f offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: f offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: t offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: t offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: f offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: f offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: t offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: t offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: f offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: f offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: t offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: t offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: f offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: f offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 53: RESULT: t offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 53: RESULT: t offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 66: QUERY: close CUR with 0 parameter on connection main
+[NO_PID]: ecpg_execute on line 66: query: close CUR; with 0 parameter(s) on connection main
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 66: using PQexec
+[NO_PID]: ecpg_execute on line 66: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 66 Ok: CLOSE CURSOR
+[NO_PID]: ecpg_execute on line 66: OK: CLOSE CURSOR
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGdeallocate line 70: NAME: f
+[NO_PID]: ECPGdeallocate on line 70: name f
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGprepare line 70: NAME: f QUERY: select * from test where $1 = amount
+[NO_PID]: ECPGprepare on line 70: name f; query: "select * from test where $1 = amount"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 73: QUERY: declare CUR3 cursor for select * from test where $1 = amount with 1 parameter on connection main
+[NO_PID]: ecpg_execute on line 73: query: declare CUR3 cursor for select * from test where $1 = amount; with 1 parameter(s) on connection main
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 73: using PQexecParams
+[NO_PID]: ecpg_execute on line 73: using PQexecParams
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: free_params line 73: parameter 1 = 1
+[NO_PID]: free_params on line 73: parameter 1 = 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 73 Ok: DECLARE CURSOR
+[NO_PID]: ecpg_execute on line 73: OK: DECLARE CURSOR
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 74: QUERY: fetch in CUR3 with 0 parameter on connection main
+[NO_PID]: ecpg_execute on line 74: query: fetch in CUR3; with 0 parameter(s) on connection main
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 74: using PQexec
+[NO_PID]: ecpg_execute on line 74: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 74: Correctly got 1 tuples with 3 fields
+[NO_PID]: ecpg_execute on line 74: correctly got 1 tuples with 3 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 74: RESULT: db: 'r1' offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 74: RESULT: db: 'r1' offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 74: RESULT: 1 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 74: RESULT: 1 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 74: RESULT: f offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 74: RESULT: f offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 87: QUERY: close CUR3 with 0 parameter on connection main
+[NO_PID]: ecpg_execute on line 87: query: close CUR3; with 0 parameter(s) on connection main
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 87: using PQexec
+[NO_PID]: ecpg_execute on line 87: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 87 Ok: CLOSE CURSOR
+[NO_PID]: ecpg_execute on line 87: OK: CLOSE CURSOR
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 88: QUERY: drop table test with 0 parameter on connection main
+[NO_PID]: ecpg_execute on line 88: query: drop table test ; with 0 parameter(s) on connection main
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 88: using PQexec
+[NO_PID]: ecpg_execute on line 88: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 88 Ok: DROP TABLE
+[NO_PID]: ecpg_execute on line 88: OK: DROP TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 89 action = commit connection = main
+[NO_PID]: ECPGtrans on line 89: action "commit"; connection "main"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGdeallocate line 0: NAME: f
+[NO_PID]: ECPGdeallocate on line 0: name f
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGdeallocate line 0: NAME: i
+[NO_PID]: ECPGdeallocate on line 0: name i
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection main closed.
+[NO_PID]: ecpg_finish: connection main closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGsetcommit line 16 action = on connection = regress1
+[NO_PID]: ECPGsetcommit on line 16: action "on"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 20: QUERY: create table T ( Item1 int , Item2 int ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 20: query: create table T ( Item1 int , Item2 int ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 20: using PQexec
+[NO_PID]: ecpg_execute on line 20: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 20 Ok: CREATE TABLE
+[NO_PID]: ecpg_execute on line 20: OK: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 22: QUERY: insert into T values ( 1 , null ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 22: query: insert into T values ( 1 , null ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 22: using PQexec
+[NO_PID]: ecpg_execute on line 22: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 22 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 22: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 23: QUERY: insert into T values ( 1 , 1 ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 23: query: insert into T values ( 1 , 1 ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 23: using PQexec
+[NO_PID]: ecpg_execute on line 23: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 23 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 23: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 24: QUERY: insert into T values ( 1 , 2 ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 24: query: insert into T values ( 1 , 2 ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 24: using PQexec
+[NO_PID]: ecpg_execute on line 24: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 24 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 24: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26: QUERY: select Item2 from T order by Item2 nulls last with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 26: query: select Item2 from T order by Item2 nulls last; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26: using PQexec
+[NO_PID]: ecpg_execute on line 26: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26: Correctly got 3 tuples with 1 fields
+[NO_PID]: ecpg_execute on line 26: correctly got 3 tuples with 1 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 26: RESULT: 1 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 26: RESULT: 1 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 26: RESULT: 2 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 26: RESULT: 2 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 26: RESULT: offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 26: RESULT: offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 31: QUERY: drop table T with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 31: query: drop table T ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 31: using PQexec
+[NO_PID]: ecpg_execute on line 31: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 31 Ok: DROP TABLE
+[NO_PID]: ecpg_execute on line 31: OK: DROP TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection regress1 closed.
+[NO_PID]: ecpg_finish: connection regress1 closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGsetcommit line 16 action = on connection = regress1
+[NO_PID]: ECPGsetcommit on line 16: action "on"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 20: QUERY: create table "My_Table" ( Item1 int , Item2 text ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 20: query: create table "My_Table" ( Item1 int , Item2 text ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 20: using PQexec
+[NO_PID]: ecpg_execute on line 20: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 20 Ok: CREATE TABLE
+[NO_PID]: ecpg_execute on line 20: OK: CREATE TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 22: QUERY: show standard_conforming_strings with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 22: query: show standard_conforming_strings; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 22: using PQexec
+[NO_PID]: ecpg_execute on line 22: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 22: Correctly got 1 tuples with 1 fields
+[NO_PID]: ecpg_execute on line 22: correctly got 1 tuples with 1 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 22: RESULT: off offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 22: RESULT: off offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26: QUERY: insert into "My_Table" values ( 1 , 'a\\\\b' ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 26: query: insert into "My_Table" values ( 1 , 'a\\\\b' ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGnoticeReceiver nonstandard use of \\ in a string literal
+[NO_PID]: ECPGnoticeReceiver: nonstandard use of \\ in a string literal
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: raising sqlcode 0
[NO_PID]: sqlca: code: 0, state: 22P06
-[NO_PID]: ecpg_execute line 26: using PQexec
+[NO_PID]: ecpg_execute on line 26: using PQexec
[NO_PID]: sqlca: code: 0, state: 22P06
-[NO_PID]: ecpg_execute line 26 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 26: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 22P06
-sql error nonstandard use of \\ in a string literal
-[NO_PID]: ecpg_execute line 28: QUERY: insert into "My_Table" values ( 1 , E'a\\\\b' ) with 0 parameter on connection regress1
+sql error: nonstandard use of \\ in a string literal
+[NO_PID]: ecpg_execute on line 28: query: insert into "My_Table" values ( 1 , E'a\\\\b' ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 28: using PQexec
+[NO_PID]: ecpg_execute on line 28: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 28 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 28: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 30: QUERY: set standard_conforming_strings to on with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 30: query: set standard_conforming_strings to on; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 30: using PQexec
+[NO_PID]: ecpg_execute on line 30: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 30 Ok: SET
+[NO_PID]: ecpg_execute on line 30: OK: SET
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 33: QUERY: insert into "My_Table" values ( 2 , 'a\\\\b' ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 33: query: insert into "My_Table" values ( 2 , 'a\\\\b' ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 33: using PQexec
+[NO_PID]: ecpg_execute on line 33: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 33 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 33: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35: QUERY: insert into "My_Table" values ( 2 , E'a\\\\b' ) with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 35: query: insert into "My_Table" values ( 2 , E'a\\\\b' ) ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35: using PQexec
+[NO_PID]: ecpg_execute on line 35: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 35 Ok: INSERT 0 1
+[NO_PID]: ecpg_execute on line 35: OK: INSERT 0 1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ECPGtrans line 37 action = begin transaction connection = regress1
+[NO_PID]: ECPGtrans on line 37: action "begin transaction "; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 40: QUERY: declare C cursor for select * from "My_Table" with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 40: query: declare C cursor for select * from "My_Table" ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 40: using PQexec
+[NO_PID]: ecpg_execute on line 40: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 40 Ok: DECLARE CURSOR
+[NO_PID]: ecpg_execute on line 40: OK: DECLARE CURSOR
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 46: QUERY: fetch C with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 46: query: fetch C; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 46: using PQexec
+[NO_PID]: ecpg_execute on line 46: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 46: Correctly got 1 tuples with 2 fields
+[NO_PID]: ecpg_execute on line 46: correctly got 1 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 46: RESULT: 1 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 46: RESULT: 1 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 46: RESULT: a\\b offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 46: RESULT: a\\b offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 46: QUERY: fetch C with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 46: query: fetch C; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 46: using PQexec
+[NO_PID]: ecpg_execute on line 46: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 46: Correctly got 1 tuples with 2 fields
+[NO_PID]: ecpg_execute on line 46: correctly got 1 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 46: RESULT: 1 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 46: RESULT: 1 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 46: RESULT: a\\b offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 46: RESULT: a\\b offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 46: QUERY: fetch C with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 46: query: fetch C; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 46: using PQexec
+[NO_PID]: ecpg_execute on line 46: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 46: Correctly got 1 tuples with 2 fields
+[NO_PID]: ecpg_execute on line 46: correctly got 1 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 46: RESULT: 2 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 46: RESULT: 2 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 46: RESULT: a\\\\b offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 46: RESULT: a\\\\b offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 46: QUERY: fetch C with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 46: query: fetch C; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 46: using PQexec
+[NO_PID]: ecpg_execute on line 46: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 46: Correctly got 1 tuples with 2 fields
+[NO_PID]: ecpg_execute on line 46: correctly got 1 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 46: RESULT: 2 offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 46: RESULT: 2 offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 46: RESULT: a\\b offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 46: RESULT: a\\b offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 46: QUERY: fetch C with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 46: query: fetch C; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 46: using PQexec
+[NO_PID]: ecpg_execute on line 46: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 46: Correctly got 0 tuples with 2 fields
+[NO_PID]: ecpg_execute on line 46: correctly got 0 tuples with 2 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: raising sqlcode 100 in line 46, 'No data found in line 46.'.
+[NO_PID]: raising sqlcode 100 on line 46: no data found on line 46
[NO_PID]: sqlca: code: 100, state: 02000
-[NO_PID]: ECPGtrans line 50 action = rollback connection = regress1
+[NO_PID]: ECPGtrans on line 50: action "rollback"; connection "regress1"
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 51: QUERY: drop table "My_Table" with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 51: query: drop table "My_Table" ; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 51: using PQexec
+[NO_PID]: ecpg_execute on line 51: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 51 Ok: DROP TABLE
+[NO_PID]: ecpg_execute on line 51: OK: DROP TABLE
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection regress1 closed.
+[NO_PID]: ecpg_finish: connection regress1 closed
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: sqlca: code: 0, state: 00000
[NO_PID]: ECPGconnect: opening database regress1 on <DEFAULT> port <DEFAULT>
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 18: QUERY: set search_path to 'public' with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 18: query: set search_path to 'public'; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 18: using PQexec
+[NO_PID]: ecpg_execute on line 18: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 18 Ok: SET
+[NO_PID]: ecpg_execute on line 18: OK: SET
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 19: QUERY: show search_path with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 19: query: show search_path; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 19: using PQexec
+[NO_PID]: ecpg_execute on line 19: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 19: Correctly got 1 tuples with 1 fields
+[NO_PID]: ecpg_execute on line 19: correctly got 1 tuples with 1 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 19: RESULT: public offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 19: RESULT: public offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 22: QUERY: set standard_conforming_strings to off with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 22: query: set standard_conforming_strings to off; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 22: using PQexec
+[NO_PID]: ecpg_execute on line 22: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 22 Ok: SET
+[NO_PID]: ecpg_execute on line 22: OK: SET
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 23: QUERY: show standard_conforming_strings with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 23: query: show standard_conforming_strings; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 23: using PQexec
+[NO_PID]: ecpg_execute on line 23: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 23: Correctly got 1 tuples with 1 fields
+[NO_PID]: ecpg_execute on line 23: correctly got 1 tuples with 1 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 23: RESULT: off offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 23: RESULT: off offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26: QUERY: set time zone PST8PDT with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 26: query: set time zone PST8PDT; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26: using PQexec
+[NO_PID]: ecpg_execute on line 26: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 26 Ok: SET
+[NO_PID]: ecpg_execute on line 26: OK: SET
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 27: QUERY: show time zone with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 27: query: show time zone; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 27: using PQexec
+[NO_PID]: ecpg_execute on line 27: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 27: Correctly got 1 tuples with 1 fields
+[NO_PID]: ecpg_execute on line 27: correctly got 1 tuples with 1 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 27: RESULT: PST8PDT offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 27: RESULT: PST8PDT offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 30: QUERY: set transaction isolation level read committed with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 30: query: set transaction isolation level read committed; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 30: using PQexec
+[NO_PID]: ecpg_execute on line 30: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 30 Ok: SET
+[NO_PID]: ecpg_execute on line 30: OK: SET
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 31: QUERY: show transaction isolation level with 0 parameter on connection regress1
+[NO_PID]: ecpg_execute on line 31: query: show transaction isolation level; with 0 parameter(s) on connection regress1
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 31: using PQexec
+[NO_PID]: ecpg_execute on line 31: using PQexec
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_execute line 31: Correctly got 1 tuples with 1 fields
+[NO_PID]: ecpg_execute on line 31: correctly got 1 tuples with 1 fields
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_get_data line 31: RESULT: read committed offset: -1 array: Yes
+[NO_PID]: ecpg_get_data on line 31: RESULT: read committed offset: -1; array: yes
[NO_PID]: sqlca: code: 0, state: 00000
-[NO_PID]: ecpg_finish: Connection regress1 closed.
+[NO_PID]: ecpg_finish: connection regress1 closed
[NO_PID]: sqlca: code: 0, state: 00000
projects / postgresql.git / commitdiff