IPDFields *ipdopts;
PutDataInfo *pdata_info;
- MYLOG(0, "%s: entering...\n", func);
+ MYLOG(0, "entering...\n");
if (!stmt)
{
if (stmt->status == STMT_DESCRIBED)
SC_recycle_statement(stmt);
- MYLOG(0, "%s: ipar=%d, paramType=%d, fCType=%d, fSqlType=%d, cbColDef=" FORMAT_ULEN ", ibScale=%d,", func, ipar, fParamType, fCType, fSqlType, cbColDef, ibScale);
+ MYLOG(0, "ipar=%d, paramType=%d, fCType=%d, fSqlType=%d, cbColDef=" FORMAT_ULEN ", ibScale=%d,", ipar, fParamType, fCType, fSqlType, cbColDef, ibScale);
MYPRINTF(0, "rgbValue=%p(" FORMAT_LEN "), pcbValue=%p\n", rgbValue, cbValueMax, pcbValue);
return SQL_SUCCESS;
BindInfoClass *bookmark;
RETCODE ret = SQL_SUCCESS;
- MYLOG(0, "%s: entering...\n", func);
+ MYLOG(0, "entering...\n");
- MYLOG(0, "**** PGAPI_BindCol: stmt = %p, icol = %d\n", stmt, icol);
+ MYLOG(0, "**** : stmt = %p, icol = %d\n", stmt, icol);
MYLOG(0, "**** : fCType=%d rgb=%p valusMax=" FORMAT_LEN " pcb=%p\n", fCType, rgbValue, cbValueMax, pcbValue);
if (!stmt)
OID pgtype;
ConnectionClass *conn;
- MYLOG(0, "%s: entering...%d\n", func, ipar);
+ MYLOG(0, "entering...%d\n", ipar);
if (!stmt)
{
StatementClass *stmt = (StatementClass *) hstmt;
CSTR func = "PGAPI_NumParams";
- MYLOG(0, "%s: entering...\n", func);
+ MYLOG(0, "entering...\n");
if (!stmt)
{
void
extend_parameter_bindings(APDFields *self, int num_params)
{
- CSTR func = "extend_parameter_bindings";
ParameterInfoClass *new_bindings;
- MYLOG(0, "%s: entering ... self=%p, parameters_allocated=%d, num_params=%d,%p\n", func, self, self->allocated, num_params, self->parameters);
+ MYLOG(0, "entering ... self=%p, parameters_allocated=%d, num_params=%d,%p\n", self, self->allocated, num_params, self->parameters);
/*
* if we have too few, allocate room for more, and copy the old
new_bindings = (ParameterInfoClass *) realloc(self->parameters, sizeof(ParameterInfoClass) * num_params);
if (!new_bindings)
{
- MYLOG(0, "%s: unable to create %d new bindings from %d old bindings\n", func, num_params, self->allocated);
+ MYLOG(0, "unable to create %d new bindings from %d old bindings\n", num_params, self->allocated);
if (self->parameters)
free(self->parameters);
self->allocated = num_params;
}
- MYLOG(0, "exit %s=%p\n", func, self->parameters);
+ MYLOG(0, "leaving %p\n", self->parameters);
}
void
extend_iparameter_bindings(IPDFields *self, int num_params)
{
- CSTR func = "extend_iparameter_bindings";
ParameterImplClass *new_bindings;
- MYLOG(0, "%s: entering ... self=%p, parameters_allocated=%d, num_params=%d\n", func, self, self->allocated, num_params);
+ MYLOG(0, "entering ... self=%p, parameters_allocated=%d, num_params=%d\n", self, self->allocated, num_params);
/*
* if we have too few, allocate room for more, and copy the old
new_bindings = (ParameterImplClass *) realloc(self->parameters, sizeof(ParameterImplClass) * num_params);
if (!new_bindings)
{
- MYLOG(0, "%s: unable to create %d new bindings from %d old bindings\n", func, num_params, self->allocated);
+ MYLOG(0, "unable to create %d new bindings from %d old bindings\n", num_params, self->allocated);
if (self->parameters)
free(self->parameters);
self->allocated = num_params;
}
- MYLOG(0, "exit %s=%p\n", func, self->parameters);
+ MYLOG(0, "leaving %p\n", self->parameters);
}
void
reset_a_parameter_binding(APDFields *self, int ipar)
{
- CSTR func = "reset_a_parameter_binding";
- MYLOG(0, "%s: entering ... self=%p, parameters_allocated=%d, ipar=%d\n", func, self, self->allocated, ipar);
+ MYLOG(0, "entering ... self=%p, parameters_allocated=%d, ipar=%d\n", self, self->allocated, ipar);
if (ipar < 1 || ipar > self->allocated)
return;
void
reset_a_iparameter_binding(IPDFields *self, int ipar)
{
- CSTR func = "reset_a_iparameter_binding";
-
- MYLOG(0, "%s: entering ... self=%p, parameters_allocated=%d, ipar=%d\n", func, self, self->allocated, ipar);
+ MYLOG(0, "entering ... self=%p, parameters_allocated=%d, ipar=%d\n", self, self->allocated, ipar);
if (ipar < 1 || ipar > self->allocated)
return;
void
APD_free_params(APDFields *apdopts, char option)
{
- CSTR func = "APD_free_params";
- MYLOG(0, "%s: ENTER, self=%p\n", func, apdopts);
+ MYLOG(0, "entering self=%p\n", apdopts);
if (!apdopts->parameters)
return;
apdopts->allocated = 0;
}
- MYLOG(0, "%s: EXIT\n", func);
+ MYLOG(0, "leaving\n");
}
void
PDATA_free_params(PutDataInfo *pdata, char option)
{
- CSTR func = "PDATA_free_params";
int i;
- MYLOG(0, "%s: ENTER, self=%p\n", func, pdata);
+ MYLOG(0, "entering self=%p\n", pdata);
if (!pdata->pdata)
return;
pdata->allocated = 0;
}
- MYLOG(0, "%s: EXIT\n", func);
+ MYLOG(0, "leaving\n");
}
/*
void
IPD_free_params(IPDFields *ipdopts, char option)
{
- CSTR func = "IPD_free_params";
-
- MYLOG(0, "%s: ENTER, self=%p\n", func, ipdopts);
+ MYLOG(0, "entering self=%p\n", ipdopts);
if (!ipdopts->parameters)
return;
ipdopts->allocated = 0;
}
- MYLOG(0, "%s: EXIT\n", func);
+ MYLOG(0, "leaving\n");
}
void
extend_column_bindings(ARDFields *self, int num_columns)
{
- CSTR func = "extend_column_bindings";
BindInfoClass *new_bindings;
int i;
- MYLOG(0, "%s: entering ... self=%p, bindings_allocated=%d, num_columns=%d\n", func, self, self->allocated, num_columns);
+ MYLOG(0, "entering ... self=%p, bindings_allocated=%d, num_columns=%d\n", self, self->allocated, num_columns);
/*
* if we have too few, allocate room for more, and copy the old
new_bindings = create_empty_bindings(num_columns);
if (!new_bindings)
{
- MYLOG(0, "%s: unable to create %d new bindings from %d old bindings\n", func, num_columns, self->allocated);
+ MYLOG(0, "unable to create %d new bindings from %d old bindings\n", num_columns, self->allocated);
if (self->bindings)
{
/* SQLExecDirect(...) # returns 5 cols */
/* SQLExecDirect(...) # returns 10 cols (now OK) */
- MYLOG(0, "exit %s=%p\n", func, self->bindings);
+ MYLOG(0, "leaving %p\n", self->bindings);
}
void
reset_a_column_binding(ARDFields *self, int icol)
{
- CSTR func = "reset_a_column_binding";
BindInfoClass *bookmark;
- MYLOG(0, "%s: entering ... self=%p, bindings_allocated=%d, icol=%d\n", func, self, self->allocated, icol);
+ MYLOG(0, "entering ... self=%p, bindings_allocated=%d, icol=%d\n", self, self->allocated, icol);
if (icol > self->allocated)
return;
{
Int2 lf;
-MYLOG(1, "ARD_unbind_cols freeall=%d allocated=%d bindings=%p\n", freeall, self->allocated, self->bindings);
+MYLOG(1, "freeall=%d allocated=%d bindings=%p\n", freeall, self->allocated, self->bindings);
for (lf = 1; lf <= self->allocated; lf++)
reset_a_column_binding(self, lf);
if (freeall)
{
Int2 lf;
-MYLOG(1, "GDATA_unbind_cols freeall=%d allocated=%d gdata=%p\n", freeall, self->allocated, self->gdata);
+MYLOG(1, "freeall=%d allocated=%d gdata=%p\n", freeall, self->allocated, self->gdata);
if (self->fdata.ttlbuf)
{
free(self->fdata.ttlbuf);
void
extend_getdata_info(GetDataInfo *self, int num_columns, BOOL shrink)
{
- CSTR func = "extend_getdata_info";
GetDataClass *new_gdata;
- MYLOG(0, "%s: entering ... self=%p, gdata_allocated=%d, num_columns=%d\n", func, self, self->allocated, num_columns);
+ MYLOG(0, "entering ... self=%p, gdata_allocated=%d, num_columns=%d\n", self, self->allocated, num_columns);
/*
* if we have too few, allocate room for more, and copy the old
new_gdata = create_empty_gdata(num_columns);
if (!new_gdata)
{
- MYLOG(0, "%s: unable to create %d new gdata from %d old gdata\n", func, num_columns, self->allocated);
+ MYLOG(0, "unable to create %d new gdata from %d old gdata\n", num_columns, self->allocated);
if (self->gdata)
{
* about it by unbinding those columns.
*/
- MYLOG(0, "exit extend_gdata_info=%p\n", self->gdata);
+ MYLOG(0, "leaving %p\n", self->gdata);
}
void reset_a_getdata_info(GetDataInfo *gdata_info, int icol)
{
void
extend_putdata_info(PutDataInfo *self, int num_params, BOOL shrink)
{
- CSTR func = "extend_putdata_info";
PutDataClass *new_pdata;
- MYLOG(0, "%s: entering ... self=%p, parameters_allocated=%d, num_params=%d\n", func, self, self->allocated, num_params);
+ MYLOG(0, "entering ... self=%p, parameters_allocated=%d, num_params=%d\n", self, self->allocated, num_params);
/*
* if we have too few, allocate room for more, and copy the old
new_pdata = (PutDataClass *) realloc(self->pdata, sizeof(PutDataClass) * num_params);
if (!new_pdata)
{
- MYLOG(0, "%s: unable to create %d new pdata from %d old pdata\n", func, num_params, self->allocated);
+ MYLOG(0, "unable to create %d new pdata from %d old pdata\n", num_params, self->allocated);
self->pdata = NULL;
self->allocated = 0;
}
}
- MYLOG(0, "exit %s=%p\n", func, self->pdata);
+ MYLOG(0, "leaving %p\n", self->pdata);
}
void reset_a_putdata_info(PutDataInfo *pdata_info, int ipar)
{
BOOL
CI_read_fields_from_pgres(ColumnInfoClass *self, PGresult *pgres)
{
- CSTR func = "CI_read_fields";
Int2 lf;
int new_num_fields;
OID new_adtid, new_relid = 0, new_attid = 0;
if (new_atttypmod < 0)
new_atttypmod = -1;
- MYLOG(0, "%s: fieldname='%s', adtid=%d, adtsize=%d, atttypmod=%d (rel,att)=(%d,%d)\n", func, new_field_name, new_adtid, new_adtsize, new_atttypmod, new_relid, new_attid);
+ MYLOG(0, "fieldname='%s', adtid=%d, adtsize=%d, atttypmod=%d (rel,att)=(%d,%d)\n", new_field_name, new_adtid, new_adtsize, new_atttypmod, new_relid, new_attid);
if (self)
CI_set_field_info(self, lf, new_field_name, new_adtid, new_adtsize, new_atttypmod, new_relid, new_attid);
ConnectionClass *conn;
CSTR func = "PGAPI_AllocConnect";
- MYLOG(0, "%s: entering...\n", func);
+ MYLOG(0, "entering...\n");
conn = CC_Constructor();
- MYLOG(0, "**** %s: henv = %p, conn = %p\n", func, henv, conn);
+ MYLOG(0, "**** henv = %p, conn = %p\n", henv, conn);
if (!conn)
{
RETCODE ret = SQL_SUCCESS;
char fchar, *tmpstr;
- MYLOG(0, "%s: entering..cbDSN=%hi.\n", func, cbDSN);
+ MYLOG(0, "entering..cbDSN=%hi.\n", cbDSN);
if (!conn)
{
free(tmpstr);
}
- QLOG(0, "conn = %p, %s(DSN='%s', UID='%s', PWD='%s')\n", conn, func, ci->dsn, ci->username, NAME_IS_VALID(ci->password) ? "xxxxx" : "");
+ QLOG(0, "conn = %p (DSN='%s', UID='%s', PWD='%s')\n", conn, ci->dsn, ci->username, NAME_IS_VALID(ci->password) ? "xxxxx" : "");
if ((fchar = CC_connect(conn, NULL)) <= 0)
{
if (SQL_SUCCESS == ret && 2 == fchar)
ret = SQL_SUCCESS_WITH_INFO;
- MYLOG(0, "%s: returning..%d.\n", func, ret);
+ MYLOG(0, "leaving..%d.\n", ret);
return ret;
}
CSTR func = "PGAPI_BrowseConnect";
ConnectionClass *conn = (ConnectionClass *) hdbc;
- MYLOG(0, "%s: entering...\n", func);
+ MYLOG(0, "entering...\n");
CC_set_error(conn, CONN_NOT_IMPLEMENTED_ERROR, "Function not implemented", func);
return SQL_ERROR;
CSTR func = "PGAPI_Disconnect";
- MYLOG(0, "%s: entering...\n", func);
+ MYLOG(0, "entering...\n");
if (!conn)
{
}
logs_on_off(-1, conn->connInfo.drivers.debug, conn->connInfo.drivers.commlog);
- MYLOG(0, "%s: about to CC_cleanup\n", func);
+ MYLOG(0, "about to CC_cleanup\n");
/* Close the connection and free statements */
CC_cleanup(conn, FALSE);
- MYLOG(0, "%s: done CC_cleanup\n", func);
- MYLOG(0, "%s: returning...\n", func);
+ MYLOG(0, "done CC_cleanup\n");
+ MYLOG(0, "leaving...\n");
return SQL_SUCCESS;
}
CSTR func = "PGAPI_FreeConnect";
EnvironmentClass *env;
- MYLOG(0, "%s: entering...\n", func);
- MYLOG(0, "**** in %s: hdbc=%p\n", func, hdbc);
+ MYLOG(0, "entering...hdbc=%p\n", hdbc);
if (!conn)
{
CC_Destructor(conn);
- MYLOG(0, "%s: returning...\n", func);
+ MYLOG(0, "leaving...\n");
return SQL_SUCCESS;
}
char
CC_Destructor(ConnectionClass *self)
{
- MYLOG(0, "enter CC_Destructor, self=%p\n", self);
+ MYLOG(0, "entering self=%p\n", self);
if (self->status == CONN_EXECUTING)
return 0;
DELETE_CONNLOCK(self);
free(self);
- MYLOG(0, "exit CC_Destructor\n");
+ MYLOG(0, "leaving\n");
return 1;
}
count = 0;
QResultClass *res;
- MYLOG(0, "CC_cursor_count: self=%p, num_stmts=%d\n", self, self->num_stmts);
+ MYLOG(0, "self=%p, num_stmts=%d\n", self, self->num_stmts);
CONNLOCK_ACQUIRE(self);
for (i = 0; i < self->num_stmts; i++)
}
CONNLOCK_RELEASE(self);
- MYLOG(0, "CC_cursor_count: returning %d\n", count);
+ MYLOG(0, "leaving %d\n", count);
return count;
}
if (!CC_is_in_trans(self))
{
QResultClass *res = CC_send_query(self, bgncmd, NULL, 0, NULL);
- MYLOG(0, "CC_begin: sending BEGIN!\n");
+ MYLOG(0, " sending BEGIN!\n");
ret = QR_command_maybe_successful(res);
QR_Destructor(res);
if (CC_is_in_trans(self))
{
QResultClass *res = CC_send_query(self, cmtcmd, NULL, 0, NULL);
- MYLOG(0, "CC_commit: sending COMMIT!\n");
+ MYLOG(0, " sending COMMIT!\n");
ret = QR_command_maybe_successful(res);
QR_Destructor(res);
}
if (CC_is_in_trans(self))
{
QResultClass *res = CC_send_query(self, rbkcmd, NULL, 0, NULL);
- MYLOG(0, "CC_abort: sending ABORT!\n");
+ MYLOG(0, " sending ABORT!\n");
ret = QR_command_maybe_successful(res);
QR_Destructor(res);
}
char
CC_set_autocommit(ConnectionClass *self, BOOL on)
{
- CSTR func = "CC_set_autocommit";
BOOL currsts = CC_is_in_autocommit(self);
if ((on && currsts) ||
(!on && !currsts))
return on;
- MYLOG(0, "%s: %d->%d\n", func, currsts, on);
+ MYLOG(0, " %d->%d\n", currsts, on);
if (CC_is_in_trans(self))
CC_commit(self);
if (on)
if (self->status == CONN_EXECUTING)
return FALSE;
- MYLOG(0, "in CC_Cleanup, self=%p\n", self);
+ MYLOG(0, "entering self=%p\n", self);
ENTER_CONN_CS(self);
/* Cancel an ongoing transaction */
}
LEAVE_CONN_CS(self);
- MYLOG(0, "exit CC_Cleanup\n");
+ MYLOG(0, "leaving\n");
return TRUE;
}
char *sqlstate = NULL;
int level = 0;
- MYLOG(1, "handle_pgres_error\n");
+ MYLOG(1, "entering\n");
sqlstate = PQresultErrorField(pgres, PG_DIAG_SQLSTATE);
if (res && pgres)
{
const char *errmsg = "The connection has been lost";
- MYLOG(0, "%s setting error message=%s\n", __FUNCTION__, errmsg);
+ MYLOG(0, "setting error message=%s\n", errmsg);
QLOG(0, "\t%ssetting error message=%s\n", __FUNCTION__, errmsg);
if (CC_get_errornumber(self) <= 0)
CC_set_error(self, CONNECTION_COMMUNICATION_ERROR, errmsg, comment);
return 0;
}
- MYLOG(0, "%s: DSN = '%s', server = '%s', port = '%s', database = '%s', username = '%s', password='%s'\n", func, ci->dsn, ci->server, ci->port, ci->database, ci->username, NAME_IS_VALID(ci->password) ? "xxxxx" : "");
+ MYLOG(0, "DSN = '%s', server = '%s', port = '%s', database = '%s', username = '%s', password='%s'\n", ci->dsn, ci->server, ci->port, ci->database, ci->username, NAME_IS_VALID(ci->password) ? "xxxxx" : "");
return 1;
}
CSTR func = "LIBPQ_CC_connect";
QResultClass *res;
- MYLOG(0, "%s: entering...\n", func);
+ MYLOG(0, "entering...\n");
if (0 == CC_initial_log(self, func))
return 0;
char ret, *saverr = NULL, retsend;
const char *errmsg = NULL;
- MYLOG(0, "%s: entering...\n", func);
-
- MYLOG(0, "sslmode=%s\n", self->connInfo.sslmode);
+ MYLOG(0, "entering...sslmode=%s\n", self->connInfo.sslmode);
ret = LIBPQ_CC_connect(self, salt_para);
if (ret <= 0)
ret = 1;
cleanup:
- MYLOG(0, "%s: returning...%d\n", func, ret);
+ MYLOG(0, "leaving...%d\n", ret);
if (NULL != saverr)
{
if (ret > 0 && CC_get_errornumber(self) <= 0)
int i;
char ret = TRUE;
- MYLOG(0, "CC_add_statement: self=%p, stmt=%p\n", self, stmt);
+ MYLOG(0, "self=%p, stmt=%p\n", self, stmt);
CONNLOCK_ACQUIRE(self);
for (i = 0; i < self->num_stmts; i++)
{
int i;
- MYLOG(0, "CC_error_statements: self=%p\n", self);
+ MYLOG(0, "entering self=%p\n", self);
for (i = 0; i < self->num_stmts; i++)
{
{
int rv;
- MYLOG(0, "enter CC_get_error\n");
+ MYLOG(0, "entering\n");
CONNLOCK_ACQUIRE(self);
CONNLOCK_RELEASE(self);
- MYLOG(0, "exit CC_get_error\n");
+ MYLOG(0, "leaving\n");
return rv;
}
QR_set_cursor(res, NULL);
QR_Destructor(wres);
CONNLOCK_ACQUIRE(self);
-MYLOG(1, " !!!! %s:%p->permanent -> %d %p\n", __FUNCTION__, res, QR_is_permanent(res), QR_get_cursor(res));
+MYLOG(1, "%p->permanent -> %d %p\n", res, QR_is_permanent(res), QR_get_cursor(res));
}
else
QR_set_permanent(res);
{
BOOL set_no_trans = FALSE;
-MYLOG(0, "CC_on_abort in opt=%x\n", opt);
+MYLOG(0, "entering opt=%x\n", opt);
CONNLOCK_ACQUIRE(conn);
if (0 != (opt & CONN_DEAD)) /* CONN_DEAD implies NO_TRANS also */
opt |= NO_TRANS;
void CC_on_abort_partial(ConnectionClass *conn)
{
-MYLOG(0, "CC_on_abort_partial in\n");
+MYLOG(0, "entering\n");
CONNLOCK_ACQUIRE(conn);
ProcessRollback(conn, TRUE, TRUE);
CC_discard_marked_objects(conn);
{
case PER_STATEMENT_ROLLBACK:
GenerateSvpCommand(self, INTERNAL_ROLLBACK_OPERATION, cmd, sizeof(cmd));
- MYLOG(0, " %s:rollback_type=%d %s\n", __FUNCTION__, rollback_type, cmd);
+ MYLOG(0, " rollback_type=%d %s\n", rollback_type, cmd);
QLOG(0, "PQexec: %p '%s'\n", self->pqconn, cmd);
pgres = PQexec(self->pqconn, cmd);
switch (PQresultStatus(pgres))
case PER_QUERY_ROLLBACK:
SPRINTF_FIXED(cmd, "%s TO %s;%s %s"
, rbkcmd, per_query_svp , rlscmd, per_query_svp);
- MYLOG(0, " %s:query_rollback PQsendQuery %s\n", __FUNCTION__, cmd);
+ MYLOG(0, " query_rollback PQsendQuery %s\n", cmd);
QLOG(0, "PQsendQuery: %p '%s'\n", self->pqconn, cmd);
PQsendQuery(self->pqconn, cmd);
ret = 0;
if (ignore_abort)
CC_set_no_error_trans(self);
else
- MYLOG(0, " %s:return error\n", __FUNCTION__);
+ MYLOG(0, " return error\n");
}
LIBPQ_update_transaction_status(self);
break;
if (appendq)
{
- MYLOG(0, "%s_append: conn=%p, query='%s'+'%s'\n", func, self, query, appendq);
+ MYLOG(0, "conn=%p, query='%s'+'%s'\n", self, query, appendq);
}
else
{
- MYLOG(0, "%s: conn=%p, query='%s'\n", func, self, query);
+ MYLOG(0, "conn=%p, query='%s'\n", self, query);
}
if (!self->pqconn)
/* append all these together, to avoid round-trips */
query_len = strlen(query);
- MYLOG(0, "%s:query_len=" FORMAT_SIZE_T "\n", __FUNCTION__, query_len);
+ MYLOG(0, "query_len=" FORMAT_SIZE_T "\n", query_len);
initPQExpBuffer(&query_buf);
/* issue_begin, query_rollback and prepend_savepoint are exclusive */
CC_set_error(self, CONN_NO_MEMORY_ERROR, "Couldn't alloc buffer for query.", "");
goto cleanup;
}
-MYLOG(1, "!!!! %s:query_buf=%s(" FORMAT_SIZE_T ")\n", __FUNCTION__, query_buf.data, strlen(query_buf.data));
+MYLOG(1, "query_buf=%s(" FORMAT_SIZE_T ")\n", query_buf.data, strlen(query_buf.data));
/* Set up notice receiver */
nrarg.conn = self;
/* portal query command, no tuples returned */
/* read in the return message from the backend */
cmdbuffer = PQcmdStatus(pgres);
- MYLOG(0, "send_query: ok - 'C' - %s\n", cmdbuffer);
+ MYLOG(0, " ok - 'C' - %s\n", cmdbuffer);
QLOG(0, "\tok: - 'C' - %s\n", cmdbuffer);
if (query_completed) /* allow for "show" style notices */
nrarg.res = res;
}
- MYLOG(0, "send_query: setting cmdbuffer = '%s'\n", cmdbuffer);
+ MYLOG(0, " setting cmdbuffer = '%s'\n", cmdbuffer);
my_trim(cmdbuffer); /* get rid of trailing space */
if (strnicmp(cmdbuffer, bgncmd, strlen(bgncmd)) == 0)
QR_set_rstatus(res, PORES_COMMAND_OK);
QR_set_command(res, cmdbuffer);
query_completed = TRUE;
- MYLOG(0, "send_query: returning res = %p\n", res);
+ MYLOG(0, " returning res = %p\n", res);
break;
case PGRES_EMPTY_QUERY:
if (stmt)
res->next->num_key_fields = stmt->num_key_fields;
}
- MYLOG(0, "send_query: 'T' no result_in: res = %p\n", res->next);
+ MYLOG(0, " 'T' no result_in: res = %p\n", res->next);
res = res->next;
nrarg.res = res;
handle_pgres_error(self, pgres, "send_query", res, TRUE);
CC_on_abort(self, CONN_DEAD);
- MYLOG(0, "send_query: error - %s\n", CC_get_errormsg(self));
+ MYLOG(0, " error - %s\n", CC_get_errormsg(self));
ReadyToReturn = TRUE;
retres = NULL;
break;
PQclear(pgres);
pgres = NULL;
}
-MYLOG(1, " !!!! %s:rollback_on_error=%d CC_is_in_trans=%d discard_next_savepoint=%d query_rollback=%d\n", __FUNCTION__, rollback_on_error, CC_is_in_trans(self), discard_next_savepoint, query_rollback);
+MYLOG(1, " rollback_on_error=%d CC_is_in_trans=%d discard_next_savepoint=%d query_rollback=%d\n", rollback_on_error, CC_is_in_trans(self), discard_next_savepoint, query_rollback);
if (rollback_on_error && CC_is_in_trans(self) && !discard_next_savepoint)
{
if (query_rollback)
CC_set_errornumber(self, CONN_ERROR_IGNORED);
if (retres)
QR_set_rstatus(retres, PORES_NONFATAL_ERROR);
-MYLOG(1, " !!!! %s:ignored abort_on_conn\n", __FUNCTION__);
+MYLOG(1, " ignored abort_on_conn\n");
}
else if (retres)
{
Int4 intParamBufs[MAX_SEND_FUNC_ARGS];
Int8 int8ParamBufs[MAX_SEND_FUNC_ARGS];
- MYLOG(0, "send_function(): conn=%p, fn_name=%s, result_is_int=%d, nargs=%d\n", self, fn_name, result_is_int, nargs);
+ MYLOG(0, "conn=%p, fn_name=%s, result_is_int=%d, nargs=%d\n", self, fn_name, result_is_int, nargs);
/* Finish the pending extended query first */
#define return DONT_CALL_RETURN_FROM_HERE???
paramTypes, (const char * const *) paramValues,
paramLengths, paramFormats, 1);
- MYLOG(0, "send_function: done sending function\n");
+ MYLOG(0, "done sending function\n");
if (PQresultStatus(pgres) == PGRES_TUPLES_OK)
QLOG(0, "\tok: - 'T' - %s\n", PQcmdStatus(pgres));
*actual_result_len = PQgetlength(pgres, 0, 0);
QLOG(0, "\tgot result with length: %d\n", *actual_result_len);
- MYLOG(0, "send_function(): got result with length %d\n", *actual_result_len);
+ MYLOG(0, "got result with length %d\n", *actual_result_len);
if (*actual_result_len > 0)
{
CSTR func = "CC_send_settings";
- MYLOG(0, "%s: entering...\n", func);
+ MYLOG(0, "entering...\n");
if (set_query == NULL) return TRUE;
if (!SQL_SUCCEEDED(result))
status = FALSE;
- MYLOG(0, "%s: result %d, status %d from '%s'\n", func, result, status, ptr);
+ MYLOG(0, "result %d, status %d from '%s'\n", result, status, ptr);
#ifdef HAVE_STRTOK_R
ptr = strtok_r(NULL, ";", &last);
CC_lookup_lo(ConnectionClass *self)
{
QResultClass *res;
- CSTR func = "CC_lookup_lo";
- MYLOG(0, "%s: entering...\n", func);
+ MYLOG(0, "entering...\n");
res = CC_send_query(self, "select oid, typbasetype from pg_type where typname = '" PG_TYPE_LO_NAME "'",
NULL, READ_ONLY_QUERY, NULL);
self->pqconn = NULL;
}
- MYLOG(0, "%s: retuning %d\n", func, ret);
+ MYLOG(0, "leaving %d\n", ret);
return ret;
}
CC_cleanup(sconn, TRUE);
if (newconn = CC_Copy(sconn), NULL == newconn)
return newconn;
- MYLOG(0, "%s:newconn=%p from %p\n", __FUNCTION__, newconn, sconn);
+ MYLOG(0, "newconn=%p from %p\n", newconn, sconn);
CC_initialize(sconn, FALSE);
if (!disposingConn)
CC_copy_conninfo(&sconn->connInfo, &newconn->connInfo);
if (SQL_C_WCHAR == fCType)
hybrid = (!is_utf8 || (same_encoding && wcs_debug));
}
- MYLOG(0, "%s:localize=%d hybrid=%d is_utf8=%d same_encoding=%d wcs_debug=%d\n", __FUNCTION__, localize_needed, hybrid, is_utf8, same_encoding, wcs_debug);
+ MYLOG(0, "localize=%d hybrid=%d is_utf8=%d same_encoding=%d wcs_debug=%d\n", localize_needed, hybrid, is_utf8, same_encoding, wcs_debug);
}
}
if (fCType == SQL_C_WCHAR)
unicode_count = convert_from_pgbinary(neut_str, NULL, 0) * 2;
else if (hybrid)
{
- MYLOG(0, "%s:hybrid estimate\n", __FUNCTION__);
+ MYLOG(0, "hybrid estimate\n");
if ((unicode_count = bindcol_hybrid_estimate(neut_str, lf_conv, &allocbuf)) < 0)
{
result = COPY_INVALID_STRING_CONVERSION;
utf8_to_ucs2_lf(neut_str, SQL_NTS, lf_conv, (SQLWCHAR *) pgdc->ttlbuf, unicode_count, FALSE);
else /* hybrid */
{
- MYLOG(0, "%s:hybrid convert\n", __FUNCTION__);
+ MYLOG(0, "hybrid convert\n");
if (bindcol_hybrid_exec((SQLWCHAR *) pgdc->ttlbuf, neut_str, unicode_count + 1, lf_conv, &allocbuf) < 0)
{
result = COPY_INVALID_STRING_CONVERSION;
int copy_len = 0, needbuflen = 0, i;
const char *ptr;
- MYLOG(0, "%s:field_type=%u type=%d\n", __FUNCTION__, field_type, fCType);
+ MYLOG(0, "field_type=%u type=%d\n", field_type, fCType);
switch (field_type)
{
memset(&std_time, 0, sizeof(SIMPLE_TIME));
- MYLOG(0, "copy_and_convert: field_type = %d, fctype = %d, value = '%s', cbValueMax=" FORMAT_LEN "\n", field_type, fCType, (value == NULL) ? "<NULL>" : value, cbValueMax);
+ MYLOG(0, "field_type = %d, fctype = %d, value = '%s', cbValueMax=" FORMAT_LEN "\n", field_type, fCType, (value == NULL) ? "<NULL>" : value, cbValueMax);
if (!value)
{
fCType = SQL_C_CHAR;
#endif
- MYLOG(0, "copy_and_convert, SQL_C_DEFAULT: fCType = %d\n", fCType);
+ MYLOG(0, ", SQL_C_DEFAULT: fCType = %d\n", fCType);
}
text_bin_handling = FALSE;
QueryParse query_org, *qp;
QueryBuild query_crt, *qb;
-MYLOG(1, "prepareParametersNoDesc\n");
+MYLOG(1, "entering\n");
qp = &query_org;
QP_initialize(qp, stmt);
qb = &query_crt;
SC_scanQueryAndCountParams(orgquery, conn, &endp1, &num_p1, &multi, NULL);
SC_scanQueryAndCountParams(srvquery, conn, &endp2, NULL, NULL, NULL);
- MYLOG(0, "%s:parsed for the first command length=" FORMAT_SSIZE_T "(" FORMAT_SSIZE_T ") num_p=%d\n", func, endp2, endp1, num_p1);
+ MYLOG(0, "parsed for the first command length=" FORMAT_SSIZE_T "(" FORMAT_SSIZE_T ") num_p=%d\n", endp2, endp1, num_p1);
pstmt = buildProcessedStmt(srvquery,
endp2 < 0 ? SQL_NTS : endp2,
fake_params ? 0 : num_p1);
num_pa += num_p1;
SC_scanQueryAndCountParams(orgquery, conn, &endp1, &num_p1, &multi, NULL);
SC_scanQueryAndCountParams(srvquery, conn, &endp2, &num_p2, NULL, NULL);
- MYLOG(0, "%s:parsed for the subsequent command length=" FORMAT_SSIZE_T "(" FORMAT_SSIZE_T ") num_p=%d\n", func, endp2, endp1, num_p1);
+ MYLOG(0, "parsed for the subsequent command length=" FORMAT_SSIZE_T "(" FORMAT_SSIZE_T ") num_p=%d\n", endp2, endp1, num_p1);
pstmt = buildProcessedStmt(srvquery,
endp2 < 0 ? SQL_NTS : endp2,
fake_params ? 0 : num_p1);
SQLSMALLINT num_pa = 0;
ProcessedStmt *pstmt;
-MYLOG(1, "prep_params_and_sync\n");
+MYLOG(1, "entering\n");
retval = SQL_ERROR;
#define return DONT_CALL_RETURN_FROM_HERE???
return SQL_SUCCESS;
}
-MYLOG(1, "prepareParameters\n");
+MYLOG(1, "calling prepareParameters\n");
if (prepareParametersNoDesc(stmt, fake_params, PARSE_PARAM_CAST) == SQL_ERROR)
return SQL_ERROR;
ConnInfo *ci = &(conn->connInfo);
const char *bestitem = NULL;
-MYLOG(1, "%s: enter prepared=%d\n", func, stmt->prepared);
+MYLOG(1, "entering prepared=%d\n", stmt->prepared);
if (!stmt->statement)
{
SC_set_error(stmt, STMT_INTERNAL_ERROR, "No statement string", func);
qb->errornumber = STMT_EXEC_ERROR;
qb->errormsg = "ODBC escape convert error";
}
- MYLOG(0, "%s convert_escape error\n", func);
+ MYLOG(0, "convert_escape error\n");
return SQL_ERROR;
}
PT_TOKEN_IGNORE(pt);
STRCPY_FIXED(tmp, "Parameters exist but IPD isn't set. Please call SQLDescribeParam()");
else
SPRINTF_FIXED(tmp, "The # of IPD parameters %d < %d the # of parameter markers", ipdopts->allocated, num_params);
- MYLOG(0, "%s:%s\n", __FUNCTION__, tmp);
+ MYLOG(0, "%s\n", tmp);
SC_set_error(stmt, STMT_COUNT_FIELD_INCORRECT, tmp, func);
return FALSE;
}
ResolveOneParam(QueryBuild *qb, QueryParse *qp, BOOL *isnull, BOOL *isbinary,
OID *pgType)
{
- CSTR func = "ResolveOneParam";
-
ConnectionClass *conn = qb->conn;
const APDFields *apdopts = qb->apdopts;
const IPDFields *ipdopts = qb->ipdopts;
*/
param_number = ++qb->param_number;
-MYLOG(1, "resolveOneParam %d(%d,%d)\n", param_number, ipdopts->allocated, apdopts->allocated);
+MYLOG(1, "para:%d(%d,%d)\n", param_number, ipdopts->allocated, apdopts->allocated);
apara = NULL;
ipara = NULL;
if (param_number < apdopts->allocated)
ipara = ipdopts->parameters + param_number;
if ((!apara || !ipara) && valueOutput)
{
- MYLOG(0, "%s:The # of (A|I)PD parameters (%d, %d) < %d the # of parameter markers\n", __FUNCTION__, apdopts->allocated, ipdopts->allocated, param_number);
+ MYLOG(0, "The # of (A|I)PD parameters (%d, %d) < %d the # of parameter markers\n", apdopts->allocated, ipdopts->allocated, param_number);
qb->errormsg = "The # of binded parameters < the # of parameter markers";
qb->errornumber = STMT_COUNT_FIELD_INCORRECT;
CVT_TERMINATE(qb); /* just in case */
if (0 != param_pgtype)
{
param_sqltype = pgtype_attr_to_concise_type(conn, param_pgtype, PG_ATP_UNSET, PG_ADT_UNSET, PG_UNKNOWNS_UNSET);
- MYLOG(0, "%s: convert from pgtype(%u) to sqltype(%d)\n", __FUNCTION__, param_pgtype, param_sqltype);
+ MYLOG(0, "convert from pgtype(%u) to sqltype(%d)\n", param_pgtype, param_sqltype);
}
}
- MYLOG(0, "%s: from(fcType)=%d, to(fSqlType)=%d(%u), *pgType=%u\n", func,
+ MYLOG(0, "from(fcType)=%d, to(fSqlType)=%d(%u), *pgType=%u\n",
param_ctype, param_sqltype, param_pgtype, *pgType);
/* Handle NULL parameter data */
case SQL_C_CHAR:
if (!same_encoding || wcs_debug)
{
- MYLOG(0, "%s:locale param convert\n", __FUNCTION__);
+ MYLOG(0, "locale param convert\n");
if ((used = bindpara_msg_to_utf8(buffer, &allocbuf, used)) < 0)
{
qb->errormsg = "Could not convert from the current locale to wide characters";
case SQL_C_WCHAR:
if (!is_utf8 || (same_encoding && wcs_debug))
{
- MYLOG(0, "%s:hybrid param convert\n", __FUNCTION__);
+ MYLOG(0, "hybrid param convert\n");
if ((used = bindpara_wchar_to_msg((SQLWCHAR *) buffer, &allocbuf, used)) < 0)
{
qb->errormsg = "Could not convert from wide characters to the current locale";
#ifdef UNICODE_SUPPORT
case SQL_C_WCHAR:
-MYLOG(0, " %s:C_WCHAR=%d contents=%s(" FORMAT_LEN ")\n", __FUNCTION__, param_ctype, buffer, used);
+MYLOG(0, " C_WCHAR=%d contents=%s(" FORMAT_LEN ")\n", param_ctype, buffer, used);
if (NULL == send_buf)
{
allocbuf = ucs2_to_utf8((SQLWCHAR *) buffer, used > 0 ? used / WCLEN : used, &used, FALSE);
processParameters(QueryParse *qp, QueryBuild *qb,
size_t *output_count, SQLLEN param_pos[][2])
{
- CSTR func = "processParameters";
int retval, innerParenthesis, param_count;
BOOL stop;
}
if (param_pos[param_count][0] >= 0)
{
- MYLOG(0, "%s closing ) not found %d\n", func, innerParenthesis);
+ MYLOG(0, "closing ) not found %d\n", innerParenthesis);
qb->errornumber = STMT_EXEC_ERROR;
qb->errormsg = "processParameters closing ) not found";
return SQL_ERROR;
static int
convert_escape(QueryParse *qp, QueryBuild *qb)
{
- CSTR func = "convert_escape";
RETCODE retval = SQL_SUCCESS;
char buf[1024], buf_small[128], key[65];
UCHAR ucv;
{
qb->errornumber = STMT_EXEC_ERROR;
qb->errormsg = "internal expression error";
- MYLOG(0, "%s internal expression error %s\n", func, mapExpr);
+ MYLOG(0, "internal expression error %s\n", mapExpr);
retval = SQL_ERROR;
break;
}
i++;
}
/** if (rgbValue)
- MYLOG(0, "convert_from_pgbinary: i=%d, rgbValue[%d] = %d, %c\n", i, o, rgbValue[o], rgbValue[o]); ***/
+ MYLOG(0, "i=%d, rgbValue[%d] = %d, %c\n", i, o, rgbValue[o], rgbValue[o]); ***/
}
if (rgbValue)
rgbValue[o] = '\0'; /* extra protection */
- MYLOG(0, "convert_from_pgbinary: in=" FORMAT_SIZE_T ", out = " FORMAT_SIZE_T "\n", ilen, o);
+ MYLOG(0, "in=" FORMAT_SIZE_T ", out = " FORMAT_SIZE_T "\n", ilen, o);
return o;
}
static size_t
convert_to_pgbinary(const char *in, char *out, size_t len, QueryBuild *qb)
{
- CSTR func = "convert_to_pgbinary";
UCHAR inc;
size_t i, o = 0;
char escape_in_literal = CC_get_escape(qb->conn);
for (i = 0; i < len; i++)
{
inc = in[i];
- MYLOG(1, "%s: in[" FORMAT_SIZE_T "] = %d, %c\n", func, i, inc, inc);
+ MYLOG(1, "in[" FORMAT_SIZE_T "] = %d, %c\n", i, inc, inc);
if (inc < 128 && (isalnum(inc) || inc == ' '))
out[o++] = inc;
else
}
}
- MYLOG(0, "%s: returning " FORMAT_SIZE_T ", out='%.*s'\n", func, o, (int) o, out);
+ MYLOG(0, "leaving " FORMAT_SIZE_T ", out='%.*s'\n", o, (int) o, out);
return o;
}
{
int i;
-MYLOG(1, "TI_Destructor count=%d\n", count);
+MYLOG(1, "entering count=%d\n", count);
if (ti)
{
for (i = 0; i < count; i++)
}
void FI_Constructor(FIELD_INFO *self, BOOL reuse)
{
-MYLOG(1, "FI_Constructor reuse=%d\n", reuse);
+MYLOG(1, "entering reuse=%d\n", reuse);
if (reuse)
FI_Destructor(&self, 1, FALSE);
memset(self, 0, sizeof(FIELD_INFO));
{
int i;
-MYLOG(1, "FI_Destructor count=%d\n", count);
+MYLOG(1, "entering count=%d\n", count);
if (fi)
{
for (i = 0; i < count; i++)
static void ARDFields_free(ARDFields * self)
{
-MYLOG(1, "ARDFields_free %p bookmark=%p\n", self, self->bookmark);
+MYLOG(1, "entering %p bookmark=%p\n", self, self->bookmark);
if (self->bookmark)
{
free(self->bookmark);
int new_num_descs;
DescriptorClass **descs;
- MYLOG(0, "CC_add_descriptor: self=%p, desc=%p\n", self, desc);
+ MYLOG(0, "entering self=%p, desc=%p\n", self, desc);
for (i = 0; i < self->num_descs; i++)
{
RETCODE ret = SQL_SUCCESS;
DescriptorClass *desc;
- MYLOG(0, "%s: entering...\n", func);
+ MYLOG(0, "entering...\n");
desc = (DescriptorClass *) malloc(sizeof(DescriptorClass));
if (desc)
RETCODE SQL_API
PGAPI_FreeDesc(SQLHDESC DescriptorHandle)
{
- CSTR func = "PGAPI_FreeDesc";
DescriptorClass *desc = (DescriptorClass *) DescriptorHandle;
RETCODE ret = SQL_SUCCESS;
- MYLOG(0, "%s: entering...\n", func);
+ MYLOG(0, "entering...\n");
DC_Destructor(desc);
if (!desc->deschd.embedded)
{
PGAPI_CopyDesc(SQLHDESC SourceDescHandle,
SQLHDESC TargetDescHandle)
{
- CSTR func = "PGAPI_CopyDesc";
RETCODE ret = SQL_ERROR;
DescriptorClass *src, *target;
DescriptorHeader *srchd, *targethd;
APDFields *apd_src, *apd_tgt;
IPDFields *ipd_src, *ipd_tgt;
- MYLOG(0, "%s: entering...\n", func);
+ MYLOG(0, "entering...\n");
src = (DescriptorClass *) SourceDescHandle;
target = (DescriptorClass *) TargetDescHandle;
srchd = &(src->deschd);
SQLSMALLINT * pcbErrorMsg,
UWORD flag)
{
- CSTR func = "PGAPI_DescError";
/* CC: return an error of a hdesc */
DescriptorClass *desc = (DescriptorClass *) hdesc;
DescriptorHeader *deschd = &(desc->deschd);
- MYLOG(0, "%s RecN=%hd\n", func, RecNumber);
+ MYLOG(0, "entering RecN=%hd\n", RecNumber);
deschd->pgerror = DC_create_errorinfo(desc);
return ER_ReturnError(deschd->pgerror, RecNumber, szSqlState,
pfNativeError, szErrorMsg, cbErrorMsgMax,
{
ci->password = decode_or_remove_braces(value);
#ifndef FORCE_PASSWORDE_DISPLAY
- MYLOG(0, "%s: key='%s' value='xxxxxxxx'\n", __FUNCTION__, attribute);
+ MYLOG(0, "key='%s' value='xxxxxxxx'\n", attribute);
printed = TRUE;
#endif
}
/* ignore first part */
}
ci->rollback_on_error = atoi(ptr + 1);
- MYLOG(0, "%s:key='%s' value='%s' rollback_on_error=%d\n",
- __FUNCTION__, attribute, value, ci->rollback_on_error);
+ MYLOG(0, "key='%s' value='%s' rollback_on_error=%d\n",
+ attribute, value, ci->rollback_on_error);
printed = TRUE;
}
}
STRCPY_FIXED(ci->sslmode, SSLMODE_DISABLE);
break;
}
- MYLOG(0, "%s:key='%s' value='%s' set to '%s'\n",
- __FUNCTION__, attribute, value, ci->sslmode);
+ MYLOG(0, "key='%s' value='%s' set to '%s'\n",
+ attribute, value, ci->sslmode);
printed = TRUE;
}
else if (stricmp(attribute, INI_ABBREVIATE) == 0)
{
setExtraOptions(ci, value, hex_format);
}
- MYLOG(0, "%s:key='%s' value='%s'(force_abbrev=%d bde=%d cvt_null_date=%x)\n",
- __FUNCTION__, attribute, value, ci->force_abbrev_connstr, ci->bde_environment, ci->cvt_null_date_string);
+ MYLOG(0, "key='%s' value='%s'(force_abbrev=%d bde=%d cvt_null_date=%x)\n",
+ attribute, value, ci->force_abbrev_connstr, ci->bde_environment, ci->cvt_null_date_string);
printed = TRUE;
}
found = FALSE;
if (!printed)
- MYLOG(0, "%s: key='%s' value='%s'%s\n", __FUNCTION__, attribute,
+ MYLOG(0, "key='%s' value='%s'%s\n", attribute,
value, found ? NULL_STRING : " not found");
return found;
static void
getCiDefaults(ConnInfo *ci)
{
- MYLOG(0, "calling %s\n", __FUNCTION__);
+ MYLOG(0, "entering\n");
ci->drivers.debug = DEFAULT_DEBUG;
ci->drivers.commlog = DEFAULT_COMMLOG;
void getDriversDefaults(const char *drivername, GLOBAL_VALUES *comval)
{
- MYLOG(0, "%s:%p of the driver %s\n", __FUNCTION__, comval, NULL_IF_NULL(drivername));
+ MYLOG(0, "%p of the driver %s\n", comval, NULL_IF_NULL(drivername));
get_Ci_Drivers(drivername, ODBCINST_INI, comval);
if (NULL != drivername)
STR_TO_NAME(comval->drivername, drivername);
void
getDSNinfo(ConnInfo *ci, const char *configDrvrname)
{
- CSTR func = "getDSNinfo";
char *DSN = ci->dsn;
char temp[LARGE_REGISTRY_LEN];
const char *drivername;
* If a driver keyword was present, then dont use a DSN and return.
* If DSN is null and no driver, then use the default datasource.
*/
- MYLOG(0, "%s: DSN=%s driver=%s&%s\n", func, DSN,
+ MYLOG(0, "entering DSN=%s driver=%s&%s\n", DSN,
ci->drivername, NULL_IF_NULL(configDrvrname));
getCiDefaults(ci);
static void
get_Ci_Drivers(const char *section, const char *filename, GLOBAL_VALUES *comval)
{
- CSTR func = "get_Ci_Drivers";
char temp[256];
BOOL inst_position = (stricmp(filename, ODBCINST_INI) == 0);
if (0 != strcmp(ODBCINST_INI, filename))
- MYLOG(0, "%s:setting %s position of %s(%p)\n", func, filename, section, comval);
+ MYLOG(0, "setting %s position of %s(%p)\n", filename, section, comval);
/*
* It's not appropriate to handle debug or commlog here.
void
CC_conninfo_init(ConnInfo *conninfo, UInt4 option)
{
- CSTR func = "CC_conninfo_init";
- MYLOG(0, "%s opt=%d\n", func, option);
+ MYLOG(0, "entering opt=%d\n", option);
if (0 != (CLEANUP_FOR_REUSE & option))
CC_conninfo_release(conninfo);
CORR_STRCPY(extra_systable_prefixes);
CORR_STRCPY(protocol);
- MYLOG(0, "copy_globals driver=%s\n", SAFE_NAME(to->drivername));
+ MYLOG(0, "driver=%s\n", SAFE_NAME(to->drivername));
}
void finalize_globals(GLOBAL_VALUES *glbv)
const char * drivername = NULL;
GLOBAL_VALUES defval;
-MYLOG(0, "!!!! %s;%d in\n", __FUNCTION__, src);
+MYLOG(0, "entering src=%d\n", src);
init_globals(&defval);
switch (src)
{
{
GLOBAL_VALUES *comval;
-// MYLOG(0, "!!!! %s in\n", __FUNCTION__);
+MYLOG(2, "entering\n");
comval = &(ci->drivers);
comval->commlog = IsDlgButtonChecked(hdlg, DRV_COMMLOG);
GLOBAL_VALUES defval;
// if (WM_INITDIALOG == wMsg || WM_COMMAND == wMsg)
-// MYLOG(0, "!!!! %s:%d in\n", __FUNCTION__, wMsg);
+// MYLOG(0, "entering wMsg=%d\n", wMsg);
init_globals(&defval);
switch (wMsg)
{
char strbuf[128];
// if (WM_INITDIALOG == wMsg || WM_COMMAND == wMsg)
-// MYLOG(0, "!!!! %s:%d in\n", __FUNCTION__, wMsg);
+// MYLOG(0, "entering wMsg=%d in\n", wMsg);
switch (wMsg)
{
case WM_INITDIALOG:
{
char buf[128];
- MYLOG(0, "%s: got ci = %p\n", __FUNCTION__, ci);
+ MYLOG(0, "entering got ci=%p\n", ci);
/* Readonly */
ITOA_FIXED(ci->onlyread, IsDlgButtonChecked(hdlg, DS_READONLY));
BOOL enable;
// if (WM_INITDIALOG == wMsg || WM_COMMAND == wMsg)
-// MYLOG(0, "!!!! %s:%d in\n", __FUNCTION__, wMsg);
+// MYLOG(0, "entering wMsg=%d in\n", wMsg);
switch (wMsg)
{
case WM_INITDIALOG:
BOOL enable = TRUE;
static BOOL defset = FALSE;
-MYLOG(0, "!!!! %s in\n", __FUNCTION__);
+MYLOG(0, "entering\n");
#ifdef _HANDLE_ENLIST_IN_DTC_
switch (ci->xa_opt)
{
PQCONNINFOPARSEPROC pproc = NULL;
PQCONNINFOFREEPROC fproc = NULL;
- MYLOG(0, "%s: got ci = %p\n", __FUNCTION__, ci);
+ MYLOG(0, "entering got ci=%p\n", ci);
/* Datasource libpq parameters */
GetDlgItemText(hdlg, DS_LIBPQOPT, pqopt, sizeof(pqopt));
DWORD cmd;
if (WM_INITDIALOG == wMsg || WM_COMMAND == wMsg)
-MYLOG(0, "!!!! %s:%d in\n", __FUNCTION__, wMsg);
+MYLOG(0, "entering wMsg=%d\n", wMsg);
switch (wMsg)
{
case WM_INITDIALOG:
int reqs = 0;
- MYLOG(0, "%s: entering...\n", func);
+ MYLOG(0, "entering...\n");
if (!conn)
{
connStrIn = make_string(szConnStrIn, cbConnStrIn, NULL, 0);
#ifdef FORCE_PASSWORD_DISPLAY
- MYLOG(0, "**** PGAPI_DriverConnect: fDriverCompletion=%d, connStrIn='%s'\n", fDriverCompletion, connStrIn);
+ MYLOG(0, "**** fDriverCompletion=%d, connStrIn='%s'\n", fDriverCompletion, connStrIn);
#else
if (get_mylog())
{
char *hide_str = hide_password(connStrIn);
- MYLOG(0, "**** PGAPI_DriverConnect: fDriverCompletion=%d, connStrIn='%s'\n", fDriverCompletion, NULL_IF_NULL(hide_str));
+ MYLOG(0, "**** fDriverCompletion=%d, connStrIn='%s'\n", fDriverCompletion, NULL_IF_NULL(hide_str));
if (hide_str)
free(hide_str);
}
}
#endif /* FORCE_PASSWORD_DISPLAY */
- MYLOG(0, "PGAPI_DriverConnect: returning %d\n", result);
+ MYLOG(0, "leaving %d\n", result);
return result;
}
{
LRESULT dialog_result;
- MYLOG(0, "dconn_DoDialog: ci = %p\n", ci);
+ MYLOG(0, "entering ci = %p\n", ci);
if (hwnd)
{
if (-1 == dialog_result)
{
int errc = GetLastError();
- MYLOG(0, " %s:LastError=%d\n", __FUNCTION__, errc);
+ MYLOG(0, " LastError=%d\n", errc);
}
if (!dialog_result || (dialog_result == -1))
return SQL_NO_DATA_FOUND;
return SQL_SUCCESS;
}
- MYLOG(0, " %s:No window specified\n", __FUNCTION__);
+ MYLOG(0, " No window specified\n");
return SQL_ERROR;
}
{
if (!delp) /* error */
{
- MYLOG(0, "%s closing bracket doesn't exist 1\n", __FUNCTION__);
+ MYLOG(0, "closing bracket doesn't exist 1\n");
ret = FALSE;
goto cleanup;
}
closep = strchr(delp + 1, CLOSING_BRACKET);
if (!closep) /* error */
{
- MYLOG(0, "%s closing bracket doesn't exist 2\n", __FUNCTION__);
+ MYLOG(0, "closing bracket doesn't exist 2\n");
ret = FALSE;
goto cleanup;
}
eoftok = TRUE;
break;
}
-MYLOG(0, "%s subsequent char to the closing bracket is %c value=%s\n", __FUNCTION__, closep[1], value);
+MYLOG(0, "subsequent char to the closing bracket is %c value=%s\n", closep[1], value);
ret = FALSE;
goto cleanup;
}
CSTR func = "PGAPI_AllocEnv";
SQLRETURN ret = SQL_SUCCESS;
- MYLOG(0, "**** in %s ** \n", func);
+ MYLOG(0, "entering\n");
/*
* For systems on which none of the constructor-making
ret = SQL_ERROR;
}
- MYLOG(0, "** exit %s: phenv = %p **\n", func, *phenv);
+ MYLOG(0, "leaving phenv=%p\n", *phenv);
return ret;
}
SQLRETURN ret = SQL_SUCCESS;
EnvironmentClass *env = (EnvironmentClass *) henv;
- MYLOG(0, "**** in PGAPI_FreeEnv: env = %p ** \n", env);
+ MYLOG(0, "entering env=%p\n", env);
if (env && EN_Destructor(env))
{
SQLSMALLINT * pcbErrorMsg,
UWORD flag)
{
- CSTR func = "ER_ReturnError";
/* CC: return an error of a hstmt */
PG_ErrorInfo *error;
BOOL partial_ok = ((flag & PODBC_ALLOW_PARTIAL_EXTRACT) != 0);
return SQL_NO_DATA_FOUND;
error = pgerror;
msg = error->__error_message;
- MYLOG(0, "%s: status = %d, msg = #%s#\n", func, error->status, msg);
+ MYLOG(0, "entering status = %d, msg = #%s#\n", error->status, msg);
msglen = (SQLSMALLINT) strlen(msg);
/*
* Even though an application specifies a larger error message
BOOL once_again = FALSE;
ssize_t msglen;
- MYLOG(0, "**** PGAPI_ConnectError: hdbc=%p <%d>\n", hdbc, cbErrorMsgMax);
+ MYLOG(0, "entering hdbc=%p <%d>\n", hdbc, cbErrorMsgMax);
if (RecNumber != 1 && RecNumber != -1)
return SQL_NO_DATA_FOUND;
if (cbErrorMsgMax < 0)
char *msg = NULL;
int status;
- MYLOG(0, "**** PGAPI_EnvError: henv=%p <%d>\n", henv, cbErrorMsgMax);
+ MYLOG(0, "entering henv=%p <%d>\n", henv, cbErrorMsgMax);
if (RecNumber != 1 && RecNumber != -1)
return SQL_NO_DATA_FOUND;
if (cbErrorMsgMax < 0)
if (WSAStartup(wVersionRequested, &wsaData))
{
- MYLOG(0, "%s: WSAStartup error\n", __FUNCTION__);
+ MYLOG(0, " WSAStartup error\n");
return rv;
}
/* Verify that this is the minimum version of WinSock */
;
else
{
- MYLOG(0, "%s: WSAStartup version=(%d,%d)\n", __FUNCTION__,
+ MYLOG(0, " WSAStartup version=(%d,%d)\n",
LOBYTE(wsaData.wVersion), HIBYTE(wsaData.wVersion));
goto cleanup;
}
rv = (EnvironmentClass *) malloc(sizeof(EnvironmentClass));
if (NULL == rv)
{
- MYLOG(0, "%s: malloc error\n", __FUNCTION__);
+ MYLOG(0, " malloc error\n");
goto cleanup;
}
rv->errormsg = 0;
int lf, nullcnt;
char rv = 1;
- MYLOG(0, "in EN_Destructor, self=%p\n", self);
+ MYLOG(0, "entering self=%p\n", self);
if (!self)
return 0;
#ifdef WIN32
WSACleanup();
#endif
- MYLOG(0, "exit EN_Destructor: rv = %d\n", rv);
+ MYLOG(0, "leaving rv=%d\n", rv);
#ifdef _MEMORY_DEBUG_
debug_memory_check();
#endif /* _MEMORY_DEBUG_ */
ConnectionClass **newa;
char ret = FALSE;
- MYLOG(0, "EN_add_connection: self = %p, conn = %p\n", self, conn);
+ MYLOG(0, "entering self = %p, conn = %p\n", self, conn);
ENTER_CONNS_CS;
for (i = 0; i < conns_count; i++)
RETCODE retval = SQL_SUCCESS;
BOOL prepared;
- MYLOG(0, "%s: entering...\n", func);
+ MYLOG(0, "entering...\n");
#define return DONT_CALL_RETURN_FROM_HERE???
/* StartRollbackState(self); */
switch (self->status)
{
case STMT_DESCRIBED:
- MYLOG(0, "**** PGAPI_Prepare: STMT_DESCRIBED, recycle\n");
+ MYLOG(0, "**** STMT_DESCRIBED, recycle\n");
SC_recycle_statement(self); /* recycle the statement, but do
* not remove parameter bindings */
break;
case STMT_FINISHED:
- MYLOG(0, "**** PGAPI_Prepare: STMT_FINISHED, recycle\n");
+ MYLOG(0, "**** STMT_FINISHED, recycle\n");
SC_recycle_statement(self); /* recycle the statement, but do
* not remove parameter bindings */
break;
case STMT_ALLOCATED:
- MYLOG(0, "**** PGAPI_Prepare: STMT_ALLOCATED, copy\n");
+ MYLOG(0, "**** STMT_ALLOCATED, copy\n");
self->status = STMT_READY;
break;
case STMT_READY:
- MYLOG(0, "**** PGAPI_Prepare: STMT_READY, change SQL\n");
+ MYLOG(0, "**** STMT_READY, change SQL\n");
if (NOT_YET_PREPARED != prepared)
SC_recycle_statement(self); /* recycle the statement */
break;
case STMT_EXECUTING:
- MYLOG(0, "**** PGAPI_Prepare: STMT_EXECUTING, error!\n");
+ MYLOG(0, "**** STMT_EXECUTING, error!\n");
SC_set_error(self, STMT_SEQUENCE_ERROR, "PGAPI_Prepare(): The handle does not point to a statement that is ready to be executed", func);
cleanup:
#undef return
-MYLOG(1, "SQLPrepare return=%d\n", retval);
+MYLOG(1, "leaving %d\n", retval);
return retval;
}
CSTR func = "PGAPI_ExecDirect";
const ConnectionClass *conn = SC_get_conn(stmt);
- MYLOG(0, "%s: entering...%x\n", func, flag);
+ MYLOG(0, "entering...%x\n", flag);
if (result = SC_initialize_and_recycle(stmt), SQL_SUCCESS != result)
return result;
return SQL_ERROR;
}
- MYLOG(0, "**** %s: hstmt=%p, statement='%s'\n", func, hstmt, stmt->statement);
+ MYLOG(0, "**** hstmt=%p, statement='%s'\n", hstmt, stmt->statement);
if (0 != (flag & PODBC_WITH_HOLD))
SC_set_with_hold(stmt);
return SQL_ERROR;
}
- MYLOG(0, "%s: calling PGAPI_Execute...\n", func);
+ MYLOG(0, "calling PGAPI_Execute...\n");
result = PGAPI_Execute(hstmt, flag);
- MYLOG(0, "%s: returned %hd from PGAPI_Execute\n", func, result);
+ MYLOG(0, "leaving %hd\n", result);
return result;
}
*exec_end = FALSE;
conn = SC_get_conn(stmt);
- MYLOG(0, "%s: copying statement params: trans_status=%d, len=" FORMAT_SIZE_T ", stmt='%s'\n", func, conn->transact_status, strlen(stmt->statement), stmt->statement);
+ MYLOG(0, "copying statement params: trans_status=%d, len=" FORMAT_SIZE_T ", stmt='%s'\n", conn->transact_status, strlen(stmt->statement), stmt->statement);
#define return DONT_CALL_RETURN_FROM_HERE???
#define RETURN(code) { retval = code; goto cleanup; }
int
StartRollbackState(StatementClass *stmt)
{
- CSTR func = "StartRollbackState";
int ret;
ConnectionClass *conn;
ConnInfo *ci = NULL;
-MYLOG(1, "%s:%p->external=%d\n", func, stmt, stmt->external);
+MYLOG(1, "entering %p->external=%d\n", stmt, stmt->external);
conn = SC_get_conn(stmt);
if (conn)
ci = &conn->connInfo;
ENTER_CONN_CS(conn);
conn->lock_CC_for_rb++;
}
-MYLOG(1, " !!!! %s:%p->accessed=%d opt=%u in_progress=%u prev=%u\n", __FUNCTION__, conn, CC_accessed_db(conn), option, conn->opt_in_progress, conn->opt_previous);
+MYLOG(1, " %p->accessed=%d opt=%u in_progress=%u prev=%u\n", conn, CC_accessed_db(conn), option, conn->opt_in_progress, conn->opt_previous);
conn->opt_in_progress &= option;
switch (stmt->statement_type)
{
}
}
CC_set_accessed_db(conn);
-MYLOG(1, "%s:%p->accessed=%d\n", func, conn, CC_accessed_db(conn));
+MYLOG(1, "leaving %p->accessed=%d\n", conn, CC_accessed_db(conn));
return ret;
}
ConnectionClass *conn = SC_get_conn(stmt);
BOOL start_stmt = FALSE;
-MYLOG(1, "%s:%p->accessed=%d is_in=%d is_rb=%d is_tc=%d\n", func, conn, CC_accessed_db(conn),
+MYLOG(1, "entering %p->accessed=%d is_in=%d is_rb=%d is_tc=%d\n", conn, CC_accessed_db(conn),
CC_is_in_trans(conn), SC_is_rb_stmt(stmt), SC_is_tc_stmt(stmt));
if (conn->lock_CC_for_rb > 0)
- MYLOG(0, "%s:in_progress=%u previous=%d\n", func, conn->opt_in_progress, conn->opt_previous);
+ MYLOG(0, "in_progress=%u previous=%d\n", conn->opt_in_progress, conn->opt_previous);
switch (ret)
{
case SQL_NEED_DATA:
}
else if (errorOnly)
return ret;
-MYLOG(1, "ret=%d\n", ret);
+MYLOG(1, "\tret=%d\n", ret);
cleanup:
#ifdef NOT_USED
if (!SC_is_prepare_statement(stmt) && ONCE_DESCRIBED == stmt->prepared)
{
LEAVE_CONN_CS(conn);
conn->lock_CC_for_rb--;
- MYLOG(1, " %s:release conn_lock\n", __FUNCTION__);
+ MYLOG(1, " release conn_lock\n");
}
CC_start_stmt(conn);
}
+ MYLOG(1, "leaving %d\n", ret);
return ret;
}
BOOL exec_end, recycled = FALSE, recycle = TRUE;
SQLSMALLINT num_params;
- MYLOG(0, "%s: entering...%x\n", func, flag);
+ MYLOG(0, "entering...%x\n", flag);
conn = SC_get_conn(stmt);
apdopts = SC_get_APDF(stmt);
SC_recycle_statement(stmt);
}
- MYLOG(0, "%s: clear errors...\n", func);
+ MYLOG(0, "clear errors...\n");
SC_clear_error(stmt);
if (!stmt->statement)
{
SC_set_error(stmt, STMT_NO_STMTSTRING, "This handle does not have a SQL statement stored in it", func);
- MYLOG(0, "%s: problem with handle\n", func);
+ MYLOG(0, "problem with handle\n");
return SQL_ERROR;
}
*/
else if (stmt->status == STMT_FINISHED)
{
- MYLOG(0, "%s: recycling statement (should have been done by app)...\n", func);
+ MYLOG(0, "recycling statement (should have been done by app)...\n");
/******** Is this really NEEDED ? ******/
SC_recycle_statement(stmt);
recycled = TRUE;
(stmt->status != STMT_ALLOCATED && stmt->status != STMT_READY))
{
SC_set_error(stmt, STMT_STATUS_ERROR, "The handle does not point to a statement that is ready to be executed", func);
- MYLOG(0, "%s: problem with statement\n", func);
+ MYLOG(0, "problem with statement\n");
retval = SQL_ERROR;
goto cleanup;
}
goto next_param_row;
}
cleanup:
-MYLOG(0, "retval=%d\n", retval);
+MYLOG(0, "leaving retval=%d\n", retval);
SC_setInsertedTable(stmt, retval);
#undef return
return retval;
char ok;
int lf;
- MYLOG(0, "entering %s: hdbc=%p, henv=%p\n", func, hdbc, henv);
+ MYLOG(0, "entering hdbc=%p, henv=%p\n", hdbc, henv);
if (hdbc == SQL_NULL_HDBC && henv == SQL_NULL_HENV)
{
/* If manual commit and in transaction, then proceed. */
if (CC_loves_visible_trans(conn) && CC_is_in_trans(conn))
{
- MYLOG(0, "PGAPI_Transact: sending on conn %p '%d'\n", conn, fType);
+ MYLOG(0, "sending on conn %p '%d'\n", conn, fType);
ok = (SQL_COMMIT == fType) ? CC_commit(conn) : CC_abort(conn);
if (!ok)
ConnectionClass *conn;
RETCODE ret = SQL_SUCCESS;
- MYLOG(0, "%s: entering...\n", func);
+ MYLOG(0, "entering...\n");
/* Check if this can handle canceling in the middle of a SQLPutData? */
if (!stmt)
ConnectionClass *conn = (ConnectionClass *) hdbc;
RETCODE result;
- MYLOG(0, "%s: entering...cbSqlStrIn=%d\n", func, cbSqlStrIn);
+ MYLOG(0, "entering...cbSqlStrIn=%d\n", cbSqlStrIn);
ptr = (cbSqlStrIn == 0) ? "" : make_string(szSqlStrIn, cbSqlStrIn, NULL, 0);
if (!ptr)
Int2 num_p;
ConnectionClass *conn = NULL;
- MYLOG(0, "%s: entering...\n", func);
+ MYLOG(0, "entering...\n");
conn = SC_get_conn(stmt);
estmt = stmt->execute_delegate ? stmt->execute_delegate : stmt;
apdopts = SC_get_APDF(estmt);
- MYLOG(0, "%s: data_at_exec=%d, params_alloc=%d\n", func, estmt->data_at_exec, apdopts->allocated);
+ MYLOG(0, "\tdata_at_exec=%d, params_alloc=%d\n", estmt->data_at_exec, apdopts->allocated);
#define return DONT_CALL_RETURN_FROM_HERE???
if (SC_AcceptedCancelRequest(stmt))
cleanup:
#undef return
SC_setInsertedTable(stmt, retval);
- MYLOG(0, "%s: returning %d\n", func, retval);
+ MYLOG(0, "leaving %d\n", retval);
return retval;
}
SQLLEN putlen;
BOOL lenset = FALSE, handling_lo = FALSE;
- MYLOG(0, "%s: entering...\n", func);
+ MYLOG(0, "entering...\n");
#define return DONT_CALL_RETURN_FROM_HERE???
if (SC_AcceptedCancelRequest(stmt))
if (!estmt->put_data)
{ /* first call */
- MYLOG(0, "PGAPI_PutData: (1) cbValue = " FORMAT_LEN "\n", cbValue);
+ MYLOG(0, "(1) cbValue = " FORMAT_LEN "\n", cbValue);
estmt->put_data = TRUE;
else
{
/* calling SQLPutData more than once */
- MYLOG(0, "PGAPI_PutData: (>1) cbValue = " FORMAT_LEN "\n", cbValue);
+ MYLOG(0, "(>1) cbValue = " FORMAT_LEN "\n", cbValue);
/* if (current_iparam->SQLType == SQL_LONGVARBINARY) */
if (handling_lo)
RETCODE result = SQL_ERROR;
char odbcver[16];
- MYLOG(0, "%s: entering...fInfoType=%d\n", func, fInfoType);
+ MYLOG(0, "entering...fInfoType=%d\n", fInfoType);
if (!conn)
{
result = SQL_SUCCESS;
- MYLOG(0, "%s: p='%s', len=" FORMAT_ULEN ", value=" FORMAT_ULEN ", cbMax=%d\n", func, p ? p : "<NULL>", len, value, cbInfoValueMax);
+ MYLOG(0, "p='%s', len=" FORMAT_ULEN ", value=" FORMAT_ULEN ", cbMax=%d\n", p ? p : "<NULL>", len, value, cbInfoValueMax);
/*
* NOTE, that if rgbInfoValue is NULL, then no warnings or errors
Int2 sqlType;
RETCODE result = SQL_SUCCESS;
- MYLOG(0, "%s: entering...fSqlType = %d\n", func, fSqlType);
+ MYLOG(0, "entering...fSqlType=%d\n", fSqlType);
if (result = SC_initialize_and_recycle(stmt), SQL_SUCCESS != result)
return result;
SQLUSMALLINT fFunction,
SQLUSMALLINT * pfExists)
{
- CSTR func = "PGAPI_GetFunctions";
ConnectionClass *conn = (ConnectionClass *) hdbc;
ConnInfo *ci = &(conn->connInfo);
- MYLOG(0, "%s: entering...%u\n", func, fFunction);
+ MYLOG(0, "entering...%u\n", fFunction);
if (fFunction == SQL_API_ALL_FUNCTIONS)
{
srclen = (SQLLEN) strlen((char *) src);
if (srclen <= 0)
return dest;
-MYLOG(0, "simple in=%s(" FORMAT_LEN ")\n", src, srclen);
+MYLOG(0, "entering in=%s(" FORMAT_LEN ")\n", src, srclen);
encoded_str_constr(&encstr, conn->ccsc, (char *) src);
dest = malloc(2 * srclen + 1);
if (!dest) return NULL;
dest[outlen++] = *in;
}
dest[outlen] = '\0';
-MYLOG(0, "simple output=%s(%d)\n", dest, outlen);
+MYLOG(0, "leaving output=%s(%d)\n", dest, outlen);
return dest;
}
/* if (srclen <= 0) */
if (srclen < 0)
return dest;
-MYLOG(0, "adjust in=%.*s(%d)\n", srclen, src, srclen);
+MYLOG(0, "entering in=%.*s(%d)\n", srclen, src, srclen);
encoded_str_constr(&encstr, conn->ccsc, (char *) src);
dest = malloc(4 * srclen + 1);
if (!dest) return NULL;
dest[outlen++] = SEARCH_PATTERN_ESCAPE;
}
dest[outlen] = '\0';
-MYLOG(0, "adjust output=%s(%d)\n", dest, outlen);
+MYLOG(0, "leaving output=%s(%d)\n", dest, outlen);
return dest;
}
SQLLEN cbRelname, cbRelkind, cbSchName;
EnvironmentClass *env;
- MYLOG(0, "%s: entering...stmt=%p scnm=%p len=%d\n", func, stmt, szTableOwner, cbTableOwner);
+ MYLOG(0, "entering...stmt=%p scnm=%p len=%d\n", stmt, szTableOwner, cbTableOwner);
if (result = SC_initialize_and_recycle(stmt), SQL_SUCCESS != result)
return result;
* set_tuplefield_string(&tuple[TABLES_SCHEMA_NAME], table_owner);
*/
- MYLOG(0, "%s: table_name = '%s'\n", func, table_name);
+ MYLOG(0, "table_name = '%s'\n", table_name);
if (list_schemas || !list_some)
set_tuplefield_string(&tuple[TABLES_SCHEMA_NAME], GET_SCHEMA_NAME(table_owner));
if (htbl_stmt)
PGAPI_FreeStmt(htbl_stmt, SQL_DROP);
- MYLOG(0, "%s: EXIT, stmt=%p, ret=%d\n", func, stmt, ret);
+ MYLOG(0, "leaving stmt=%p, ret=%d\n", stmt, ret);
return ret;
}
const SQLCHAR *szSchemaName;
BOOL setIdentity = FALSE;
- MYLOG(0, "%s: entering...stmt=%p scnm=%p len=%d\n", func, stmt, szTableOwner, cbTableOwner);
+ MYLOG(0, "entering...stmt=%p scnm=%p len=%d\n", stmt, szTableOwner, cbTableOwner);
if (result = SC_initialize_and_recycle(stmt), SQL_SUCCESS != result)
return result;
}
col_stmt = (StatementClass *) hcol_stmt;
- MYLOG(0, "%s: hcol_stmt = %p, col_stmt = %p\n", func, hcol_stmt, col_stmt);
+ MYLOG(0, "hcol_stmt = %p, col_stmt = %p\n", hcol_stmt, col_stmt);
result = PGAPI_ExecDirect(hcol_stmt, (SQLCHAR *) columns_query.data, SQL_NTS, PODBC_RDONLY);
if (!SQL_SUCCEEDED(result))
free(escColumnName);
if (hcol_stmt)
PGAPI_FreeStmt(hcol_stmt, SQL_DROP);
- MYLOG(0, "%s: EXIT, stmt=%p\n", func, stmt);
+ MYLOG(0, "leaving stmt=%p\n", stmt);
return result;
}
const char *eq_string;
int result_cols;
- MYLOG(0, "%s: entering...stmt=%p scnm=%p len=%d colType=%d scope=%d\n", func, stmt, szTableOwner, cbTableOwner, fColType, fScope);
+ MYLOG(0, "entering...stmt=%p scnm=%p len=%d colType=%d scope=%d\n", stmt, szTableOwner, cbTableOwner, fColType, fScope);
if (result = SC_initialize_and_recycle(stmt), SQL_SUCCESS != result)
return result;
}
col_stmt = (StatementClass *) hcol_stmt;
- MYLOG(0, "%s: hcol_stmt = %p, col_stmt = %p\n", func, hcol_stmt, col_stmt);
+ MYLOG(0, "hcol_stmt = %p, col_stmt = %p\n", hcol_stmt, col_stmt);
if (PQExpBufferDataBroken(columns_query))
{
SC_set_current_col(stmt, -1);
if (hcol_stmt)
PGAPI_FreeStmt(hcol_stmt, SQL_DROP);
- MYLOG(0, "%s: EXIT, stmt=%p\n", func, stmt);
+ MYLOG(0, "leaving stmt=%p\n", stmt);
return result;
}
OID ioid;
Int4 relhasoids;
- MYLOG(0, "%s: entering...stmt=%p scnm=%p len=%d\n", func, stmt, szTableOwner, cbTableOwner);
+ MYLOG(0, "entering...stmt=%p scnm=%p len=%d\n", stmt, szTableOwner, cbTableOwner);
if (result = SC_initialize_and_recycle(stmt), SQL_SUCCESS != result)
return result;
column_names[total_columns].pnum = field_number;
total_columns++;
- MYLOG(0, "%s: column_name = '%s'\n", func, column_name);
+ MYLOG(0, "column_name = '%s'\n", column_name);
result = PGAPI_Fetch(hcol_stmt);
}
if (OID_ATTNUM == attnum)
{
set_tuplefield_string(&tuple[STATS_COLUMN_NAME], OID_NAME);
- MYLOG(0, "%s: column name = oid\n", func);
+ MYLOG(0, "column name = oid\n");
}
else if (0 == attnum)
{
if (unknownf)
{
set_tuplefield_string(&tuple[STATS_COLUMN_NAME], "UNKNOWN");
- MYLOG(0, "%s: column name = UNKNOWN\n", func);
+ MYLOG(0, "column name = UNKNOWN\n");
}
else
{
set_tuplefield_string(&tuple[STATS_COLUMN_NAME], column_names[matchidx].col_name);
- MYLOG(0, "%s: column name = '%s'\n", func, column_names[matchidx].col_name);
+ MYLOG(0, "column name = '%s'\n", column_names[matchidx].col_name);
}
}
SC_set_rowset_start(stmt, -1, FALSE);
SC_set_current_col(stmt, -1);
- MYLOG(0, "%s: EXIT, stmt=%p, ret=%d\n", func, stmt, ret);
+ MYLOG(0, "leaving stmt=%p, ret=%d\n", stmt, ret);
return ret;
}
BOOL search_pattern;
QResultClass *res = NULL;
- MYLOG(0, "%s: entering...\n", func);
+ MYLOG(0, "entering...\n");
/* Neither Access or Borland care about this. */
const char *eq_string;
char *escSchemaName = NULL, *escTableName = NULL;
- MYLOG(0, "%s: entering...stmt=%p scnm=%p len=%d\n", func, stmt, szTableOwner, cbTableOwner);
+ MYLOG(0, "entering...stmt=%p scnm=%p len=%d\n", stmt, szTableOwner, cbTableOwner);
if (result = SC_initialize_and_recycle(stmt), SQL_SUCCESS != result)
return result;
ret = SQL_ERROR;
goto cleanup;
}
- MYLOG(0, "%s: tables_query='%s'\n", func, tables_query.data);
+ MYLOG(0, "tables_query='%s'\n", tables_query.data);
result = PGAPI_ExecDirect(htbl_stmt, (SQLCHAR *) tables_query.data, SQL_NTS, PODBC_RDONLY);
if (!SQL_SUCCEEDED(result))
SC_set_rowset_start(stmt, -1, FALSE);
SC_set_current_col(stmt, -1);
- MYLOG(0, "%s: EXIT, stmt=%p, ret=%d\n", func, stmt, ret);
+ MYLOG(0, "leaving stmt=%p, ret=%d\n", stmt, ret);
return ret;
}
UInt4 relid1, relid2;
const char *eq_string;
- MYLOG(0, "%s: entering...stmt=%p\n", func, stmt);
+ MYLOG(0, "entering...stmt=%p\n", stmt);
if (result = SC_initialize_and_recycle(stmt), SQL_SUCCESS != result)
return result;
{
char *escSchemaName;
- MYLOG(0, "%s: entering Foreign Key Case #2\n", func);
+ MYLOG(0, " Foreign Key Case #2\n");
escFkTableName = simpleCatalogEscape((SQLCHAR *) fk_table_needed, SQL_NTS, conn);
schema_str(schema_needed, sizeof(schema_needed), szFkTableOwner, cbFkTableOwner, TABLE_IS_VALID(szFkTableName, cbFkTableName), conn);
escSchemaName = simpleCatalogEscape((SQLCHAR *) schema_needed, SQL_NTS, conn);
got_pkname = TRUE;
}
pkey_text = getClientColumnName(conn, relid2, pkey_ptr, &pkey_alloced);
- MYLOG(0, "%s: pkey_ptr='%s', pkey='%s'\n", func, pkey_text, pkey);
+ MYLOG(0, "pkey_ptr='%s', pkey='%s'\n", pkey_text, pkey);
if (strcmp(pkey_text, pkey))
{
num_keys = 0;
pkey_text = getClientColumnName(conn, relid2, pkey_ptr, &pkey_alloced);
fkey_text = getClientColumnName(conn, relid1, fkey_ptr, &fkey_alloced);
- MYLOG(0, "%s: pk_table = '%s', pkey_ptr = '%s'\n", func, pk_table_fetched, pkey_text);
+ MYLOG(0, "pk_table = '%s', pkey_ptr = '%s'\n", pk_table_fetched, pkey_text);
set_tuplefield_string(&tuple[FKS_PKTABLE_CAT], CurrCat(conn));
set_tuplefield_string(&tuple[FKS_PKTABLE_SCHEM], GET_SCHEMA_NAME(schema_fetched));
set_tuplefield_string(&tuple[FKS_PKTABLE_NAME], pk_table_fetched);
set_tuplefield_string(&tuple[FKS_PKCOLUMN_NAME], pkey_text);
- MYLOG(0, "%s: fk_table_needed = '%s', fkey_ptr = '%s'\n", func, fk_table_needed, fkey_text);
+ MYLOG(0, "fk_table_needed = '%s', fkey_ptr = '%s'\n", fk_table_needed, fkey_text);
set_tuplefield_string(&tuple[FKS_FKTABLE_CAT], CurrCat(conn));
set_tuplefield_string(&tuple[FKS_FKTABLE_SCHEM], GET_SCHEMA_NAME(schema_needed));
set_tuplefield_string(&tuple[FKS_FKTABLE_NAME], fk_table_needed);
set_tuplefield_string(&tuple[FKS_FKCOLUMN_NAME], fkey_text);
- MYLOG(0, "%s: upd_rule_type = '%i', del_rule_type = '%i'\n, trig_name = '%s'", func, upd_rule_type, del_rule_type, trig_args);
+ MYLOG(0, "upd_rule_type = '%i', del_rule_type = '%i'\n, trig_name = '%s'", upd_rule_type, del_rule_type, trig_args);
set_tuplefield_int2(&tuple[FKS_KEY_SEQ], (Int2) (k + 1));
set_tuplefield_int2(&tuple[FKS_UPDATE_RULE], upd_rule_type);
set_tuplefield_int2(&tuple[FKS_DELETE_RULE], del_rule_type);
SC_set_rowset_start(stmt, -1, FALSE);
SC_set_current_col(stmt, -1);
- MYLOG(0, "%s(): EXIT, stmt=%p, ret=%d\n", func, stmt, ret);
+ MYLOG(0, "leaving stmt=%p, ret=%d\n", stmt, ret);
return ret;
}
int ret_col = -1, ext_pos = -1, poid_pos = -1, attid_pos = -1, attname_pos = -1;
UInt4 poid = 0, newpoid;
- MYLOG(0, "%s: entering...\n", func);
+ MYLOG(0, "entering...\n");
if (result = SC_initialize_and_recycle(stmt), SQL_SUCCESS != result)
return result;
const char *like_or_eq, *op_string;
BOOL search_pattern;
- MYLOG(0, "%s: entering... scnm=%p len=%d\n", func, szProcOwner, cbProcOwner);
+ MYLOG(0, "entering... scnm=%p len=%d\n", szProcOwner, cbProcOwner);
if (result = SC_initialize_and_recycle(stmt), SQL_SUCCESS != result)
return result;
char *escSchemaName = NULL, *escTableName = NULL;
BOOL search_pattern;
- MYLOG(0, "%s: entering... scnm=%p len-%d\n", func, szTableOwner, cbTableOwner);
+ MYLOG(0, "entering... scnm=%p len-%d\n", szTableOwner, cbTableOwner);
if (result = SC_initialize_and_recycle(stmt), SQL_SUCCESS != result)
return result;
const char *eq_string;
- MYLOG(0, "%s: entering...stmt=%p\n", func, stmt);
+ MYLOG(0, "entering...stmt=%p\n", stmt);
if (result = SC_initialize_and_recycle(stmt), SQL_SUCCESS != result)
return result;
*/
if (NULL != fk_table_needed)
{
- MYLOG(0, "%s: entering Foreign Key Case #2\n", func);
+ MYLOG(0, " Foreign Key Case #2\n");
escTableName = simpleCatalogEscape((SQLCHAR *) fk_table_needed, SQL_NTS, conn);
schema_str(schema_needed, sizeof(schema_needed), szFkTableOwner, cbFkTableOwner, TABLE_IS_VALID(szFkTableName, cbFkTableName), conn);
relqual = "\n and conrelid = c.oid";
SC_set_rowset_start(stmt, -1, FALSE);
SC_set_current_col(stmt, -1);
- MYLOG(0, "%s(): EXIT, stmt=%p, ret=%d\n", func, stmt, ret);
+ MYLOG(0, "leaving stmt=%p, ret=%d\n", stmt, ret);
return ret;
}
void * alloced = realloc(ptr, size);
if (!alloced)
{
- MYLOG(0, "%s:%s %p error\n", ALCERR, __FUNCTION__, ptr);
+ MYLOG(0, "%s %p error\n", ALCERR, ptr);
}
else if (!ptr)
{
}
}
- inolog("%s %p->%p\n", __FUNCTION__, ptr, alloced);
+ inolog("%p->%p\n", ptr, alloced);
return alloced;
}
char * pgdebug_strdup(const char * ptr)
char * alloced = strdup(ptr);
if (!alloced)
{
- MYLOG(0, "%s:%s %p error\n", ALCERR, __FUNCTION__, ptr);
+ MYLOG(0, "%s %p error\n", ALCERR, ptr);
}
else
{
altbl[tbsize].len = strlen(ptr) + 1;
tbsize++;
}
- inolog("%s %p->%p(%s)\n", __FUNCTION__, ptr, alloced, alloced);
+ inolog("%p->%p(%s)\n", ptr, alloced, alloced);
return alloced;
}
if (!ptr)
{
- MYLOG(0, "%s:%sing null ptr\n", ALCERR, __FUNCTION__);
+ MYLOG(0, "%s null ptr\n", ALCERR);
return;
}
for (i = 0; i < tbsize; i++)
}
if (! freed)
{
- MYLOG(0, "%s:%sing not found ptr %p\n", ALCERR, __FUNCTION__, ptr);
+ MYLOG(0, "%s not found ptr %p\n", ALCERR, ptr);
return;
}
else
- inolog("%sing ptr=%p\n", __FUNCTION__, ptr);
+ inolog("ptr=%p\n", ptr);
free(ptr);
}
{
if (!out || !in)
{
- MYLOG(0, "%s:%s null pointer out=%p,in=%p\n", ALCERR, __FUNCTION__, out, in);
+ MYLOG(0, "%s null pointer out=%p,in=%p\n", ALCERR, out, in);
return NULL;
}
out_check(out, strlen(in) + 1, __FUNCTION__);
{
if (!out || !in)
{
- MYLOG(0, "%s:%s null pointer out=%p,in=%p\n", ALCERR, __FUNCTION__, out, in);
+ MYLOG(0, "%s null pointer out=%p,in=%p\n", ALCERR, out, in);
return NULL;
}
out_check(out, len, __FUNCTION__);
{
if (!out || !in)
{
- MYLOG(0, "%s:%s null pointer out=%p,in=%p\n", ALCERR, __FUNCTION__, out, in);
+ MYLOG(0, "%s null pointer out=%p,in=%p\n", ALCERR, out, in);
return NULL;
}
out_check(out, len, __FUNCTION__);
{
if (!out || !in)
{
- MYLOG(0, "%s:%s null pointer out=%p,in=%p\n", ALCERR, __FUNCTION__, out, in);
+ MYLOG(0, "%s null pointer out=%p,in=%p\n", ALCERR, out, in);
return NULL;
}
out_check(out, len, __FUNCTION__);
{
if (!out)
{
- MYLOG(0, "%s:%s null pointer out=%p\n", ALCERR, __FUNCTION__, out);
+ MYLOG(0, "%s null pointer out=%p\n", ALCERR, out);
return NULL;
}
out_check(out, len, __FUNCTION__);
length = strlen((char *) s);
else
{
- MYLOG(0, "make_string invalid length=%d\n", len);
+ MYLOG(0, "invalid length=%d\n", len);
return NULL;
}
if (buf)
ptr++;
if ((enc_no= pg_char_to_encoding(ptr)) >= 0)
wenc = pg_encoding_to_char(enc_no);
- MYLOG(0, "%s locale=%s enc=%s\n", __FUNCTION__, loc, wenc ? wenc : "(null)");
+ MYLOG(0, "locale=%s enc=%s\n", loc, wenc ? wenc : "(null)");
}
#endif /* WIN32 */
return wenc;
RETCODE ret;
StatementClass *stmt = (StatementClass *) StatementHandle;
- MYLOG(0, "[%s]\n", __FUNCTION__);
+ MYLOG(0, "Entering\n");
ENTER_STMT_CS(stmt);
SC_clear_error(stmt);
StartRollbackState(stmt);
RETCODE SQL_API
SQLCancel(HSTMT StatementHandle)
{
- MYLOG(0, "[%s]\n", __FUNCTION__);
+ MYLOG(0, "Entering\n");
/* Not that neither ENTER_STMT_CS nor StartRollbackState is called */
/* SC_clear_error((StatementClass *) StatementHandle); maybe this neither */
if (SC_connection_lost_check((StatementClass *) StatementHandle, __FUNCTION__))
ConnInfo *ci = &(SC_get_conn(stmt)->connInfo);
UWORD flag = PODBC_SEARCH_PUBLIC_SCHEMA;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
ConnectionClass *conn = (ConnectionClass *) ConnectionHandle;
- MYLOG(0, "[%s]\n", __FUNCTION__);
+ MYLOG(0, "Entering\n");
CC_examine_global_transaction(conn);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
RETCODE ret;
ConnectionClass *conn = (ConnectionClass *) hdbc;
- MYLOG(0, "[%s]\n", __FUNCTION__);
+ MYLOG(0, "Entering\n");
CC_examine_global_transaction(conn);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
RETCODE ret;
ConnectionClass *conn = (ConnectionClass *) hdbc;
- MYLOG(0, "[%s]\n", __FUNCTION__);
+ MYLOG(0, "Entering\n");
CC_examine_global_transaction(conn);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
SQLCHAR *Description, SQLSMALLINT BufferLength2,
SQLSMALLINT *NameLength2)
{
- MYLOG(0, "[%s]\n", __FUNCTION__);
+ MYLOG(0, "Entering\n");
/*
* return PGAPI_DataSources(EnvironmentHandle, Direction, ServerName,
RETCODE ret;
StatementClass *stmt = (StatementClass *) StatementHandle;
- MYLOG(0, "[%s]\n", __FUNCTION__);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE SQL_API
SQLDisconnect(HDBC ConnectionHandle)
{
- CSTR func = "SQLDisconnect";
RETCODE ret;
ConnectionClass *conn = (ConnectionClass *) ConnectionHandle;
- MYLOG(0, "[%s for %p]\n", func, ConnectionHandle);
+ MYLOG(0, "Entering for %p\n", ConnectionHandle);
#ifdef _HANDLE_ENLIST_IN_DTC_
if (CC_is_in_global_trans(conn))
CALL_DtcOnDisconnect(conn);
StatementClass *stmt = (StatementClass *) StatementHandle;
UWORD flag = 0;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
StatementClass *stmt = (StatementClass *) StatementHandle;
UWORD flag = 0;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE SQL_API
SQLFetch(HSTMT StatementHandle)
{
- CSTR func = "SQLFetch";
RETCODE ret;
StatementClass *stmt = (StatementClass *) StatementHandle;
IRDFields *irdopts = SC_get_IRDF(stmt);
SQLUSMALLINT *rowStatusArray = irdopts->rowStatusArray;
SQLULEN *pcRow = irdopts->rowsFetched;
- MYLOG(0, "[[%s]]\n", func);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
StatementClass *stmt = (StatementClass *) StatementHandle;
ConnectionClass *conn = NULL;
- MYLOG(0, "[%s]\n", __FUNCTION__);
+ MYLOG(0, "Entering\n");
if (stmt)
{
RETCODE ret;
StatementClass *stmt = (StatementClass *) StatementHandle;
- MYLOG(0, "[%s]\n", __FUNCTION__);
+ MYLOG(0, "Entering\n");
ENTER_STMT_CS(stmt);
SC_clear_error(stmt);
StartRollbackState(stmt);
RETCODE ret;
StatementClass *stmt = (StatementClass *) StatementHandle;
- MYLOG(0, "[%s]\n", __FUNCTION__);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
ConnectionClass *conn = (ConnectionClass *) ConnectionHandle;
- MYLOG(0, "[%s]\n", __FUNCTION__);
+ MYLOG(0, "Entering\n");
CC_examine_global_transaction(conn);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
SQLUSMALLINT InfoType, PTR InfoValue,
SQLSMALLINT BufferLength, SQLSMALLINT *StringLength)
{
- CSTR func = "SQLGetInfo";
RETCODE ret;
ConnectionClass *conn = (ConnectionClass *) ConnectionHandle;
CC_examine_global_transaction(conn);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
- MYLOG(0, "[%s(30)]\n", func);
+ MYLOG(0, "Entering\n");
if ((ret = PGAPI_GetInfo(ConnectionHandle, InfoType, InfoValue,
BufferLength, StringLength)) == SQL_ERROR)
CC_log_error("SQLGetInfo(30)", "", conn);
RETCODE ret;
StatementClass *stmt = (StatementClass *) StatementHandle;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check((StatementClass *) StatementHandle, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
StatementClass *stmt = (StatementClass *) StatementHandle;
- MYLOG(0, "[%s]\n", __FUNCTION__);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
StatementClass *stmt = (StatementClass *) StatementHandle;
- MYLOG(0, "[%s]\n", __FUNCTION__);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
StatementClass *stmt = (StatementClass *) StatementHandle;
- MYLOG(0, "[%s]\n", __FUNCTION__);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
StatementClass *stmt = (StatementClass *) StatementHandle;
- MYLOG(0, "[%s]\n", __FUNCTION__);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
StatementClass *stmt = (StatementClass *) StatementHandle;
- MYLOG(0, "[%s]\n", __FUNCTION__);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
StatementClass *stmt = (StatementClass *) StatementHandle;
- MYLOG(0, "[%s]\n", __FUNCTION__);
+ MYLOG(0, "Entering\n");
ENTER_STMT_CS(stmt);
SC_clear_error(stmt);
StartRollbackState(stmt);
SQLSMALLINT ParameterScale, PTR ParameterValue,
SQLLEN *StrLen_or_Ind)
{
- MYLOG(0, "[%s]\n", __FUNCTION__);
+ MYLOG(0, "Entering\n");
SC_clear_error((StatementClass *) StatementHandle);
/*
StatementClass *stmt = (StatementClass *) StatementHandle;
SQLCHAR *ctName = CatalogName, *scName = SchemaName, *tbName = TableName;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
StatementClass *stmt = (StatementClass *) StatementHandle;
SQLCHAR *ctName = CatalogName, *scName = SchemaName, *tbName = TableName;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
SQLCHAR *ctName = CatalogName, *scName = SchemaName, *tbName = TableName;
UWORD flag = 0;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
*tbName = szTableName, *clName = szColumnName;
UWORD flag = 0;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
StatementClass *stmt = (StatementClass *) hstmt;
- MYLOG(0, "[%s]\n", __FUNCTION__);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
StatementClass *stmt = (StatementClass *) hstmt;
- MYLOG(0, "[%s]\n", __FUNCTION__);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
*pktbName = szPkTableName, *fkctName = szFkCatalogName,
*fkscName = szFkSchemaName, *fktbName = szFkTableName;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
StatementClass *stmt = (StatementClass *) hstmt;
- MYLOG(0, "[%s]\n", __FUNCTION__);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
ConnectionClass *conn = (ConnectionClass *) hdbc;
- MYLOG(0, "[%s]\n", __FUNCTION__);
+ MYLOG(0, "Entering\n");
CC_examine_global_transaction(conn);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
RETCODE ret;
StatementClass *stmt = (StatementClass *) hstmt;
- MYLOG(0, "[%s]\n", __FUNCTION__);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
SQLCHAR *ctName = szCatalogName, *scName = szSchemaName,
*tbName = szTableName;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
*prName = szProcName, *clName = szColumnName;
UWORD flag = 0;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
*prName = szProcName;
UWORD flag = 0;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
StatementClass *stmt = (StatementClass *) hstmt;
- MYLOG(0, "[%s]\n", __FUNCTION__);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
*tbName = szTableName;
UWORD flag = 0;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
StatementClass *stmt = (StatementClass *) hstmt;
- MYLOG(0, "[%s]\n", __FUNCTION__);
+ MYLOG(0, "Entering\n");
ENTER_STMT_CS(stmt);
SC_clear_error(stmt);
StartRollbackState(stmt);
SQLAllocHandle(SQLSMALLINT HandleType,
SQLHANDLE InputHandle, SQLHANDLE * OutputHandle)
{
- CSTR func = "SQLAllocHandle";
RETCODE ret;
ConnectionClass *conn;
- MYLOG(0, "[[%s]]\n", func);
+ MYLOG(0, "Entering\n");
switch (HandleType)
{
case SQL_HANDLE_ENV:
SQLSMALLINT ParameterScale, PTR ParameterValue,
SQLLEN *StrLen_or_Ind)
{
- CSTR func = "SQLBindParam";
RETCODE ret;
StatementClass *stmt = (StatementClass *) StatementHandle;
int BufferLength = 512; /* Is it OK ? */
- MYLOG(0, "[[%s]]\n", func);
+ MYLOG(0, "Entering\n");
ENTER_STMT_CS(stmt);
SC_clear_error(stmt);
StartRollbackState(stmt);
RETCODE SQL_API
SQLCloseCursor(HSTMT StatementHandle)
{
- CSTR func = "SQLCloseCursor";
StatementClass *stmt = (StatementClass *) StatementHandle;
RETCODE ret;
- MYLOG(0, "[[%s]]\n", func);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
#endif
)
{
- CSTR func = "SQLColAttribute";
RETCODE ret;
StatementClass *stmt = (StatementClass *) StatementHandle;
- MYLOG(0, "[[%s]]\n", func);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
SQLCopyDesc(SQLHDESC SourceDescHandle,
SQLHDESC TargetDescHandle)
{
- CSTR func = "SQLCopyDesc";
RETCODE ret;
- MYLOG(0, "[[%s]]\n", func);
+ MYLOG(0, "Entering\n");
ret = PGAPI_CopyDesc(SourceDescHandle, TargetDescHandle);
return ret;
}
SQLEndTran(SQLSMALLINT HandleType, SQLHANDLE Handle,
SQLSMALLINT CompletionType)
{
- CSTR func = "SQLEndTran";
RETCODE ret;
- MYLOG(0, "[[%s]]\n", func);
+ MYLOG(0, "Entering\n");
switch (HandleType)
{
case SQL_HANDLE_ENV:
SQLULEN *pcRow = irdopts->rowsFetched;
SQLLEN bkmarkoff = 0;
- MYLOG(0, "[[%s]] %d," FORMAT_LEN "\n", func, FetchOrientation, FetchOffset);
+ MYLOG(0, "Entering %d," FORMAT_LEN "\n", FetchOrientation, FetchOffset);
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
ret = DiscardStatementSvp(stmt,ret, FALSE);
LEAVE_STMT_CS(stmt);
if (ret != SQL_SUCCESS)
- MYLOG(0, "%s return = %d\n", func, ret);
+ MYLOG(0, "leaving return = %d\n", ret);
return ret;
}
RETCODE SQL_API
SQLFreeHandle(SQLSMALLINT HandleType, SQLHANDLE Handle)
{
- CSTR func = "SQLFreeHandle";
RETCODE ret;
StatementClass *stmt;
ConnectionClass *conn = NULL;
- MYLOG(0, "[[%s]]\n", func);
+ MYLOG(0, "Entering\n");
switch (HandleType)
{
{
RETCODE ret;
- MYLOG(0, "[[%s]]\n", __FUNCTION__);
+ MYLOG(0, "Entering\n");
ret = PGAPI_GetDescField(DescriptorHandle, RecNumber, FieldIdentifier,
Value, BufferLength, StringLength);
return ret;
SQLLEN *Length, SQLSMALLINT *Precision,
SQLSMALLINT *Scale, SQLSMALLINT *Nullable)
{
- MYLOG(0, "[[%s]]\n", __FUNCTION__);
+ MYLOG(0, "Entering\n");
MYLOG(0, "Error not implemented\n");
return SQL_ERROR;
}
PTR DiagInfo, SQLSMALLINT BufferLength,
SQLSMALLINT *StringLength)
{
- CSTR func = "SQLGetDiagField";
RETCODE ret;
- MYLOG(0, "[[%s]] Handle=(%u,%p) Rec=%d Id=%d info=(%p,%d)\n", func, HandleType, Handle, RecNumber, DiagIdentifier, DiagInfo, BufferLength);
+ MYLOG(0, "Entering Handle=(%u,%p) Rec=%d Id=%d info=(%p,%d)\n", HandleType, Handle, RecNumber, DiagIdentifier, DiagInfo, BufferLength);
ret = PGAPI_GetDiagField(HandleType, Handle, RecNumber, DiagIdentifier,
DiagInfo, BufferLength, StringLength);
return ret;
{
RETCODE ret;
- MYLOG(0, "[[%s]]\n", __FUNCTION__);
+ MYLOG(0, "Entering\n");
ret = PGAPI_GetDiagRec(HandleType, Handle, RecNumber, Sqlstate,
NativeError, MessageText, BufferLength, TextLength);
return ret;
RETCODE ret;
EnvironmentClass *env = (EnvironmentClass *) EnvironmentHandle;
- MYLOG(0, "[[%s]] %d\n", __FUNCTION__, Attribute);
+ MYLOG(0, "Entering %d\n", Attribute);
ENTER_ENV_CS(env);
ret = SQL_SUCCESS;
switch (Attribute)
{
RETCODE ret;
- MYLOG(0, "[[%s]] %d\n", __FUNCTION__, Attribute);
+ MYLOG(0, "Entering %d\n", Attribute);
CC_examine_global_transaction((ConnectionClass*) ConnectionHandle);
ENTER_CONN_CS((ConnectionClass *) ConnectionHandle);
CC_clear_error((ConnectionClass *) ConnectionHandle);
SQLINTEGER BufferLength, SQLINTEGER *StringLength)
{
RETCODE ret;
- CSTR func = "SQLGetStmtAttr";
StatementClass *stmt = (StatementClass *) StatementHandle;
- MYLOG(0, "[[%s]] Handle=%p %d\n", func, StatementHandle, Attribute);
+ MYLOG(0, "Entering Handle=%p %d\n", StatementHandle, Attribute);
ENTER_STMT_CS(stmt);
SC_clear_error(stmt);
StartRollbackState(stmt);
RETCODE ret;
ConnectionClass *conn = (ConnectionClass *) ConnectionHandle;
- MYLOG(0, "[[%s]] %d\n", __FUNCTION__, Attribute);
+ MYLOG(0, "Entering %d\n", Attribute);
CC_examine_global_transaction(conn);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
{
RETCODE ret;
- MYLOG(0, "[[%s]] h=%p rec=%d field=%d val=%p\n", __FUNCTION__, DescriptorHandle, RecNumber, FieldIdentifier, Value);
+ MYLOG(0, "Entering h=%p rec=%d field=%d val=%p\n", DescriptorHandle, RecNumber, FieldIdentifier, Value);
ret = PGAPI_SetDescField(DescriptorHandle, RecNumber, FieldIdentifier,
Value, BufferLength);
return ret;
PTR Data, SQLLEN *StringLength,
SQLLEN *Indicator)
{
- CSTR func = "SQLSetDescRec";
-
- MYLOG(0, "[[%s]]\n", func);
+ MYLOG(0, "Entering\n");
MYLOG(0, "Error not implemented\n");
return SQL_ERROR;
}
RETCODE ret;
EnvironmentClass *env = (EnvironmentClass *) EnvironmentHandle;
- MYLOG(0, "[[%s]] att=%d," FORMAT_ULEN "\n", __FUNCTION__, Attribute, (SQLULEN) Value);
+ MYLOG(0, "Entering att=%d," FORMAT_ULEN "\n", Attribute, (SQLULEN) Value);
ENTER_ENV_CS(env);
switch (Attribute)
{
SQLINTEGER Attribute, PTR Value,
SQLINTEGER StringLength)
{
- CSTR func = "SQLSetStmtAttr";
StatementClass *stmt = (StatementClass *) StatementHandle;
RETCODE ret;
- MYLOG(0, "[[%s]] Handle=%p %d," FORMAT_ULEN "\n", func, StatementHandle, Attribute, (SQLULEN) Value);
+ MYLOG(0, "Entering Handle=%p %d," FORMAT_ULEN "\n", StatementHandle, Attribute, (SQLULEN) Value);
ENTER_STMT_CS(stmt);
SC_clear_error(stmt);
StartRollbackState(stmt);
SQLBulkOperations(HSTMT hstmt, SQLSMALLINT operation)
{
RETCODE ret;
- CSTR func = "SQLBulkOperations";
StatementClass *stmt = (StatementClass *) hstmt;
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
ENTER_STMT_CS(stmt);
- MYLOG(0, "[[%s]] Handle=%p %d\n", func, hstmt, operation);
+ MYLOG(0, "Entering Handle=%p %d\n", hstmt, operation);
SC_clear_error(stmt);
StartRollbackState(stmt);
ret = PGAPI_BulkOperations(hstmt, operation);
SQLINTEGER cbValueMax,
SQLINTEGER *pcbValue)
{
- CSTR func = "SQLGetStmtAttrW";
RETCODE ret;
StatementClass *stmt = (StatementClass *) hstmt;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
ENTER_STMT_CS((StatementClass *) hstmt);
SC_clear_error((StatementClass *) hstmt);
StartRollbackState(stmt);
PTR rgbValue,
SQLINTEGER cbValueMax)
{
- CSTR func = "SQLSetStmtAttrW";
RETCODE ret;
StatementClass *stmt = (StatementClass *) hstmt;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
ENTER_STMT_CS(stmt);
SC_clear_error(stmt);
StartRollbackState(stmt);
SQLINTEGER cbValueMax,
SQLINTEGER *pcbValue)
{
- CSTR func = "SQLGetConnectAttrW";
RETCODE ret;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
CC_examine_global_transaction((ConnectionClass *) hdbc);
ENTER_CONN_CS((ConnectionClass *) hdbc);
CC_clear_error((ConnectionClass *) hdbc);
PTR rgbValue,
SQLINTEGER cbValue)
{
- CSTR func = "SQLSetConnectAttrW";
RETCODE ret;
ConnectionClass *conn = (ConnectionClass *) hdbc;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
CC_examine_global_transaction(conn);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
SQLSMALLINT FieldIdentifier, PTR Value,
SQLINTEGER BufferLength)
{
- CSTR func = "SQLSetDescFieldW";
RETCODE ret;
SQLLEN vallen;
char *uval = NULL;
BOOL val_alloced = FALSE;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
if (BufferLength > 0 || SQL_NTS == BufferLength)
{
switch (FieldIdentifier)
PTR rgbValue, SQLINTEGER cbValueMax,
SQLINTEGER *pcbValue)
{
- CSTR func = "SQLGetDescFieldW";
RETCODE ret;
SQLINTEGER blen = 0, bMax, *pcbV;
char *rgbV = NULL, *rgbVt;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
switch (iField)
{
case SQL_DESC_BASE_COLUMN_NAME:
SQLSMALLINT cbErrorMsgMax,
SQLSMALLINT *pcbErrorMsg)
{
- CSTR func = "SQLGetDiagRecW";
RETCODE ret;
SQLSMALLINT buflen, tlen;
char qstr_ansi[8], *mtxt = NULL;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
buflen = 0;
if (szErrorMsg && cbErrorMsgMax > 0)
{
SQLSMALLINT *rgbL, blen = 0, bMax;
char *rgbD = NULL, *rgbDt;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
SQLSMALLINT cbDiagInfoMax,
SQLSMALLINT *pcbDiagInfo)
{
- CSTR func = "SQLGetDiagFieldW";
RETCODE ret;
SQLSMALLINT *rgbL, blen = 0, bMax;
char *rgbD = NULL, *rgbDt;
- MYLOG(0, "[[%s]] Handle=(%u,%p) Rec=%d Id=%d info=(%p,%d)\n", func, fHandleType,
+ MYLOG(0, "Entering Handle=(%u,%p) Rec=%d Id=%d info=(%p,%d)\n", fHandleType,
handle, iRecord, fDiagField, rgbDiagInfo, cbDiagInfoMax);
switch (fDiagField)
{
SQLLEN *Length, SQLSMALLINT *Precision,
SQLSMALLINT *Scale, SQLSMALLINT *Nullable)
{
- MYLOG(0, "[[%s]]\n", __FUNCTION__);
+ MYLOG(0, "Entering\n");
MYLOG(0, "Error not implemented\n");
return SQL_ERROR;
}
PTR Data, SQLLEN *StringLength,
SQLLEN *Indicator)
{
- CSTR func = "SQLSetDescRecW";
-
- MYLOG(0, "[[%s]]\n", func);
+ MYLOG(0, "Entering\n");
MYLOG(0, "Error not implemented\n");
return SQL_ERROR;
}
UWORD flag = PODBC_SEARCH_PUBLIC_SCHEMA;
ConnInfo *ci;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
SQLWCHAR *UserName, SQLSMALLINT NameLength2,
SQLWCHAR *Authentication, SQLSMALLINT NameLength3)
{
- CSTR func = "SQLConnectW";
char *svName, *usName, *auth;
SQLLEN nmlen1, nmlen2, nmlen3;
RETCODE ret;
ConnectionClass *conn = (ConnectionClass *) ConnectionHandle;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
CC_examine_global_transaction(conn);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
RETCODE ret;
ConnectionClass *conn = (ConnectionClass *) hdbc;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
CC_examine_global_transaction(conn);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
RETCODE ret;
ConnectionClass *conn = (ConnectionClass *) hdbc;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
CC_examine_global_transaction(conn);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
SQLWCHAR *Description, SQLSMALLINT BufferLength2,
SQLSMALLINT *NameLength2)
{
- CSTR func = "SQLDataSourcesW";
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
/*
return PGAPI_DataSources(EnvironmentHandle, Direction, ServerName,
BufferLength1, NameLength1, Description, BufferLength2,
SQLSMALLINT buflen, nmlen;
char *clName = NULL, *clNamet = NULL;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
StatementClass *stmt = (StatementClass *) StatementHandle;
UWORD flag = 0;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
char *crName = NULL, *crNamet;
SQLSMALLINT clen, buflen;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
if (BufferLength > 0)
buflen = BufferLength * 3;
else
SQLUSMALLINT InfoType, PTR InfoValue,
SQLSMALLINT BufferLength, SQLSMALLINT *StringLength)
{
- CSTR func = "SQLGetInfoW";
ConnectionClass *conn = (ConnectionClass *) ConnectionHandle;
RETCODE ret;
ENTER_CONN_CS(conn);
CC_set_in_unicode_driver(conn);
CC_clear_error(conn);
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
if ((ret = PGAPI_GetInfo(ConnectionHandle, InfoType, InfoValue,
BufferLength, StringLength)) == SQL_ERROR)
CC_log_error("SQLGetInfoW", "", conn);
char *stxt;
SQLLEN slen;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
SQLSetCursorNameW(HSTMT StatementHandle,
SQLWCHAR *CursorName, SQLSMALLINT NameLength)
{
- CSTR func = "SQLSetCursorNameW";
RETCODE ret;
StatementClass *stmt = (StatementClass *) StatementHandle;
char *crName;
SQLLEN nlen;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
crName = ucs2_to_utf8(CursorName, NameLength, &nlen, FALSE);
ENTER_STMT_CS(stmt);
SC_clear_error(stmt);
ConnectionClass *conn;
BOOL lower_id;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
ConnectionClass *conn;
BOOL lower_id;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
BOOL lower_id;
UWORD flag = 0;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
BOOL lower_id;
UWORD flag = 0;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
ConnectionClass *conn;
BOOL lower_id;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
SQLINTEGER buflen, olen;
ConnectionClass *conn = (ConnectionClass *) hdbc;
- MYLOG(0, "[%s}\n", func);
+ MYLOG(0, "Entering\n");
CC_examine_global_transaction(conn);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
ConnectionClass *conn;
BOOL lower_id;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
BOOL lower_id;
UWORD flag = 0;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
conn = SC_get_conn(stmt);
lower_id = SC_is_lower_case(stmt, conn);
ctName = ucs2_to_utf8(szCatalogName, cbCatalogName, &nmlen1, lower_id);
BOOL lower_id;
UWORD flag = 0;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
BOOL lower_id;
UWORD flag = 0;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
StatementClass * stmt = (StatementClass *) StatementHandle;
- MYLOG(0, "[%s]\n", func);
+ MYLOG(0, "Entering\n");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
* positioned update isn't supported so cursor concurrency is
* read-only
*/
- MYLOG(0, "SetStmtOption(): SQL_CONCURRENCY = " FORMAT_LEN " ", vParam);
+ MYLOG(0, "SQL_CONCURRENCY = " FORMAT_LEN " ", vParam);
setval = SQL_CONCUR_READ_ONLY;
if (SQL_CONCUR_READ_ONLY == vParam)
;
* if declare/fetch, then type can only be forward. otherwise,
* it can only be forward or static.
*/
- MYLOG(0, "SetStmtOption(): SQL_CURSOR_TYPE = " FORMAT_LEN " ", vParam);
+ MYLOG(0, "SQL_CURSOR_TYPE = " FORMAT_LEN " ", vParam);
setval = SQL_CURSOR_FORWARD_ONLY;
if (ci->drivers.lie)
setval = vParam;
break;
case SQL_KEYSET_SIZE: /* ignored, but saved and returned */
- MYLOG(0, "SetStmtOption(): SQL_KEYSET_SIZE, vParam = " FORMAT_LEN "\n", vParam);
+ MYLOG(0, "SQL_KEYSET_SIZE, vParam = " FORMAT_LEN "\n", vParam);
if (conn)
conn->stmtOptions.keyset_size = vParam;
break;
case SQL_MAX_LENGTH: /* ignored, but saved */
- MYLOG(0, "SetStmtOption(): SQL_MAX_LENGTH, vParam = " FORMAT_LEN "\n", vParam);
+ MYLOG(0, "SQL_MAX_LENGTH, vParam = " FORMAT_LEN "\n", vParam);
if (conn)
conn->stmtOptions.maxLength = vParam;
if (stmt)
break;
case SQL_MAX_ROWS: /* ignored, but saved */
- MYLOG(0, "SetStmtOption(): SQL_MAX_ROWS, vParam = " FORMAT_LEN "\n", vParam);
+ MYLOG(0, "SQL_MAX_ROWS, vParam = " FORMAT_LEN "\n", vParam);
if (conn)
conn->stmtOptions.maxRows = vParam;
if (stmt)
break;
case SQL_NOSCAN: /* ignored */
- MYLOG(0, "SetStmtOption: SQL_NOSCAN, vParam = " FORMAT_LEN "\n", vParam);
+ MYLOG(0, "SQL_NOSCAN, vParam = " FORMAT_LEN "\n", vParam);
break;
case SQL_QUERY_TIMEOUT: /* ignored */
- MYLOG(0, "SetStmtOption: SQL_QUERY_TIMEOUT, vParam = " FORMAT_LEN "\n", vParam);
+ MYLOG(0, "SQL_QUERY_TIMEOUT, vParam = " FORMAT_LEN "\n", vParam);
if (conn)
conn->stmtOptions.stmt_timeout = (SQLULEN) vParam;
if (stmt)
break;
case SQL_RETRIEVE_DATA:
- MYLOG(0, "SetStmtOption(): SQL_RETRIEVE_DATA, vParam = " FORMAT_LEN "\n", vParam);
+ MYLOG(0, "SQL_RETRIEVE_DATA, vParam = " FORMAT_LEN "\n", vParam);
if (conn)
conn->stmtOptions.retrieve_data = (SQLUINTEGER) vParam;
if (stmt)
break;
case SQL_ROWSET_SIZE:
- MYLOG(0, "SetStmtOption(): SQL_ROWSET_SIZE, vParam = " FORMAT_LEN "\n", vParam);
+ MYLOG(0, "SQL_ROWSET_SIZE, vParam = " FORMAT_LEN "\n", vParam);
if (vParam < 1)
{
RETCODE retval;
BOOL autocomm_on;
- MYLOG(0, "%s: entering fOption = %d vParam = " FORMAT_LEN "\n", func, fOption, vParam);
+ MYLOG(0, "entering fOption = %d vParam = " FORMAT_LEN "\n", fOption, vParam);
if (!conn)
{
CC_log_error(func, "", NULL);
else if (!autocomm_on && SQL_AUTOCOMMIT_OFF == conn->autocommit_public)
break;
conn->autocommit_public = (autocomm_on ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF);
- MYLOG(0, "%s: AUTOCOMMIT: transact_status=%d, vparam=" FORMAT_LEN "\n", func, conn->transact_status, vParam);
+ MYLOG(0, "AUTOCOMMIT: transact_status=%d, vparam=" FORMAT_LEN "\n", conn->transact_status, vParam);
#ifdef _HANDLE_ENLIST_IN_DTC_
if (CC_is_in_global_trans(conn))
SQLLEN len = sizeof(SQLINTEGER);
SQLRETURN result = SQL_SUCCESS;
- MYLOG(0, "%s: entering...\n", func);
+ MYLOG(0, "entering...\n");
if (!conn)
{
StatementClass *stmt = (StatementClass *) hstmt;
RETCODE retval;
- MYLOG(0, "%s: entering...\n", func);
+ MYLOG(0, " entering...\n");
/*
* Though we could fake Access out by just returning SQL_SUCCESS all
SQLINTEGER len = sizeof(SQLINTEGER);
Int4 bookmark;
- MYLOG(0, "%s: entering...\n", func);
+ MYLOG(0, "entering...\n");
/*
* thought we could fake Access out by just returning SQL_SUCCESS all
break;
case SQL_CONCURRENCY: /* NOT REALLY SUPPORTED */
- MYLOG(0, "GetStmtOption(): SQL_CONCURRENCY %d\n", stmt->options.scroll_concurrency);
+ MYLOG(0, "SQL_CONCURRENCY %d\n", stmt->options.scroll_concurrency);
*((SQLINTEGER *) pvParam) = stmt->options.scroll_concurrency;
break;
case SQL_CURSOR_TYPE: /* PARTIAL SUPPORT */
- MYLOG(0, "GetStmtOption(): SQL_CURSOR_TYPE %d\n", stmt->options.cursor_type);
+ MYLOG(0, "SQL_CURSOR_TYPE %d\n", stmt->options.cursor_type);
*((SQLINTEGER *) pvParam) = stmt->options.cursor_type;
break;
case SQL_KEYSET_SIZE: /* NOT SUPPORTED, but saved */
- MYLOG(0, "GetStmtOption(): SQL_KEYSET_SIZE\n");
+ MYLOG(0, "SQL_KEYSET_SIZE\n");
*((SQLLEN *) pvParam) = stmt->options.keyset_size;
break;
case SQL_MAX_ROWS: /* NOT SUPPORTED, but saved */
*((SQLLEN *) pvParam) = stmt->options.maxRows;
- MYLOG(0, "GetSmtOption: MAX_ROWS, returning " FORMAT_LEN "\n", stmt->options.maxRows);
+ MYLOG(0, "MAX_ROWS, returning " FORMAT_LEN "\n", stmt->options.maxRows);
break;
case SQL_NOSCAN: /* NOT SUPPORTED */
{
char *str;
-MYLOG(1, "getColInfo non-manual result\n");
+MYLOG(1, "entering non-manual result\n");
fi->dquote = TRUE;
STR_TO_NAME(fi->column_name, QR_get_value_backend_text(col_info->result, k, COLUMNS_COLUMN_NAME));
OID basetype;
const char *col;
-MYLOG(1, "searchColInfo num_cols=" FORMAT_ULEN " col=%s\n", QR_get_num_cached_tuples(col_info->result), PRINT_NAME(fi->column_name));
+MYLOG(1, "entering num_cols=" FORMAT_ULEN " col=%s\n", QR_get_num_cached_tuples(col_info->result), PRINT_NAME(fi->column_name));
if (fi->attnum < 0)
return FALSE;
for (k = 0; k < QR_get_num_cached_tuples(col_info->result); k++)
if (basetype = (OID) strtoul(QR_get_value_backend_text(col_info->result, k, COLUMNS_BASE_TYPEID), NULL, 10), 0 == basetype)
basetype = (OID) strtoul(QR_get_value_backend_text(col_info->result, k, COLUMNS_FIELD_TYPE), NULL, 10);
atttypmod = QR_get_value_backend_int(col_info->result, k, COLUMNS_ATTTYPMOD, NULL);
-MYLOG(1, "searchColInfo %d attnum=%d\n", k, attnum);
+MYLOG(1, "%d attnum=%d\n", k, attnum);
if (attnum == fi->attnum &&
basetype == fi->basetype &&
atttypmod == fi->typmod)
else if (NAME_IS_VALID(fi->column_name))
{
col = QR_get_value_backend_text(col_info->result, k, COLUMNS_COLUMN_NAME);
-MYLOG(1, "searchColInfo %d col=%s\n", k, col);
+MYLOG(1, "%d col=%s\n", k, col);
if (fi->dquote)
cmp = strcmp(col, GET_NAME(fi->column_name));
else
STR_TO_NAME(fi->column_name, col);
getColInfo(col_info, fi, k);
- MYLOG(0, "PARSE: searchColInfo: \n");
+ MYLOG(0, "PARSE: \n");
return TRUE;
}
}
BOOL multi_table = FALSE;
QResultClass *res;
-MYLOG(1, "has_multi_table ntab=%d", stmt->ntab);
+MYLOG(1, "entering ntab=%d", stmt->ntab);
if (1 < stmt->ntab)
multi_table = TRUE;
else if (SC_has_join(stmt))
int i, num_fields;
BOOL fi_reuse, updatable, call_xxxxx;
-MYLOG(0, "ColAttSet in\n");
+MYLOG(0, "entering\n");
if (reloid = rti->table_oid, 0 == reloid)
return FALSE;
StatementClass *col_stmt;
QResultClass *res;
- MYLOG(0, "PARSE: Getting PG_Columns for table %u(%s)\n", greloid, PRINT_NAME(wti->table_name));
+ MYLOG(0, "entering Getting PG_Columns for table %u(%s)\n", greloid, PRINT_NAME(wti->table_name));
if (NULL == conn)
conn = SC_get_conn(stmt);
TABLE_INFO *wti = *pti;
COL_INFO *coli;
-MYLOG(1, "getCOLIfromTI reloid=%u ti=%p\n", reloid, wti);
+MYLOG(1, "entering reloid=%u ti=%p\n", reloid, wti);
if (!conn)
conn = SC_get_conn(stmt);
if (!wti) /* SQLColAttribute case */
}
else if (!colatt && stmt)
SC_set_parse_status(stmt, STMT_PARSE_FATAL);
-MYLOG(1, "getCOLIfromTI returns %d\n", found);
+MYLOG(1, "leaving returns %d\n", found);
return found;
}
SQLRETURN
SC_set_SS_columnkey(StatementClass *stmt)
{
- CSTR func = "SC_set_SS_columnkey";
IRDFields *irdflds = SC_get_IRDF(stmt);
FIELD_INFO **fi = irdflds->fi, *tfi;
size_t nfields = irdflds->nfields;
BOOL contains_key = FALSE;
int i;
-MYLOG(1, "%s:fields=" FORMAT_SIZE_T " ntab=%d\n", func, nfields, stmt->ntab);
+MYLOG(1, "entering fields=" FORMAT_SIZE_T " ntab=%d\n", nfields, stmt->ntab);
if (!fi) return ret;
if (0 >= nfields) return ret;
if (!has_multi_table(stmt) && 1 == stmt->ntab)
if (oneti == tfi->ti &&
strcmp(keycolnam, SAFE_NAME(tfi->column_name)) == 0)
{
-MYLOG(1, "%s:key %s found at %p\n", func, keycolnam, fi + i);
+MYLOG(1, "key %s found at %p\n", keycolnam, fi + i);
tfi->columnkey = TRUE;
break;
}
}
if (i >= nfields)
{
- MYLOG(0, "%s: %s not found\n", func, keycolnam);
+ MYLOG(0, "%s not found\n", keycolnam);
break;
}
ret = PGAPI_Fetch(pstmt);
goto cleanup;
ret = SQL_SUCCESS;
}
-MYLOG(1, "%s: contains_key=%d\n", func, contains_key);
+MYLOG(1, "contains_key=%d\n", contains_key);
for (i = 0; i < nfields; i++)
{
if (tfi = fi[i], NULL == tfi)
IRDFields *irdflds;
BOOL updatable = TRUE, column_has_alias = FALSE;
- MYLOG(0, "%s: entering...\n", func);
+ MYLOG(0, "entering...\n");
if (SC_parsed_status(stmt) != STMT_PARSE_NONE)
{
parse = FALSE;
}
- MYLOG(0, "done %s: parse=%d, parse_status=%d\n", func, parse, SC_parsed_status(stmt));
+ MYLOG(0, "laving parse=%d, parse_status=%d\n", parse, SC_parsed_status(stmt));
return parse;
}
SQLSMALLINT BufferLength, SQLSMALLINT *TextLength)
{
RETCODE ret;
- CSTR func = "PGAPI_GetDiagRec";
- MYLOG(0, "%s entering type=%d rec=%d\n", func, HandleType, RecNumber);
+ MYLOG(0, "entering type=%d rec=%d\n", HandleType, RecNumber);
switch (HandleType)
{
case SQL_HANDLE_ENV:
default:
ret = SQL_ERROR;
}
- MYLOG(0, "%s exiting %d\n", func, ret);
+ MYLOG(0, "leaving %d\n", ret);
return ret;
}
SQLSMALLINT pcbErrm;
ssize_t rtnlen = -1;
int rtnctype = SQL_C_CHAR;
- CSTR func = "PGAPI_GetDiagField";
- MYLOG(0, "%s entering rec=%d\n", func, RecNumber);
+ MYLOG(0, "entering rec=%d\n", RecNumber);
switch (HandleType)
{
case SQL_HANDLE_ENV:
if (StringLengthPtr)
*StringLengthPtr = (SQLSMALLINT) rtnlen;
}
- MYLOG(0, "%s exiting %d\n", func, ret);
+ MYLOG(0, "leaving %d\n", ret);
return ret;
}
RETCODE ret = SQL_SUCCESS;
SQLINTEGER len = 4;
- MYLOG(0, "PGAPI_GetConnectAttr %d\n", Attribute);
+ MYLOG(0, "entering %d\n", Attribute);
switch (Attribute)
{
case SQL_ATTR_ASYNC_ENABLE:
APDSetField(DescriptorClass *desc, SQLSMALLINT RecNumber,
SQLSMALLINT FieldIdentifier, PTR Value, SQLINTEGER BufferLength)
{
- CSTR func = "APDSetField";
RETCODE ret = SQL_SUCCESS;
APDFields *opts = &(desc->apdf);
SQLSMALLINT para_idx;
}
if (RecNumber <=0)
{
-MYLOG(1, "%s RecN=%d allocated=%d\n", func, RecNumber, opts->allocated);
+MYLOG(1, "RecN=%d allocated=%d\n", RecNumber, opts->allocated);
DC_set_error(desc, DESC_BAD_PARAMETER_NUMBER_ERROR,
"bad parameter number");
return SQL_ERROR;
}
if (RecNumber > opts->allocated)
{
-MYLOG(1, "%s RecN=%d allocated=%d\n", func, RecNumber, opts->allocated);
+MYLOG(1, "RecN=%d allocated=%d\n", RecNumber, opts->allocated);
parameter_bindings_set(opts, RecNumber, TRUE);
/* DC_set_error(desc, DESC_BAD_PARAMETER_NUMBER_ERROR,
"bad parameter number");
}
if (RecNumber <= 0 || RecNumber > ipdopts->allocated)
{
-MYLOG(1, "IPDSetField RecN=%d allocated=%d\n", RecNumber, ipdopts->allocated);
+MYLOG(1, "RecN=%d allocated=%d\n", RecNumber, ipdopts->allocated);
DC_set_error(desc, DESC_BAD_PARAMETER_NUMBER_ERROR,
"bad parameter number");
return SQL_ERROR;
break;
default:if (RecNumber <= 0 || RecNumber > opts->allocated)
{
-MYLOG(1, "APDGetField RecN=%d allocated=%d\n", RecNumber, opts->allocated);
+MYLOG(1, "RecN=%d allocated=%d\n", RecNumber, opts->allocated);
DC_set_error(desc, DESC_BAD_PARAMETER_NUMBER_ERROR,
"bad parameter number");
return SQL_ERROR;
break;
default:if (RecNumber <= 0 || RecNumber > ipdopts->allocated)
{
-MYLOG(1, "IPDGetField RecN=%d allocated=%d\n", RecNumber, ipdopts->allocated);
+MYLOG(1, "RecN=%d allocated=%d\n", RecNumber, ipdopts->allocated);
DC_set_error(desc, DESC_BAD_PARAMETER_NUMBER_ERROR,
"bad parameter number");
return SQL_ERROR;
RETCODE ret = SQL_SUCCESS;
SQLINTEGER len = 0;
- MYLOG(0, "%s Handle=%p %d\n", func, StatementHandle, Attribute);
+ MYLOG(0, "entering Handle=%p %d\n", StatementHandle, Attribute);
switch (Attribute)
{
case SQL_ATTR_FETCH_BOOKMARK_PTR: /* 16 */
BOOL unsupported = FALSE;
int newValue;
- MYLOG(0, "%s for %p: %d %p\n", func, ConnectionHandle, Attribute, Value);
+ MYLOG(0, "entering for %p: %d %p\n", ConnectionHandle, Attribute, Value);
switch (Attribute)
{
case SQL_ATTR_METADATA_ID:
RETCODE ret = SQL_SUCCESS;
DescriptorClass *desc = (DescriptorClass *) DescriptorHandle;
- MYLOG(0, "%s h=%p rec=%d field=%d blen=%d\n", func, DescriptorHandle, RecNumber, FieldIdentifier, BufferLength);
+ MYLOG(0, "entering h=%p rec=%d field=%d blen=%d\n", DescriptorHandle, RecNumber, FieldIdentifier, BufferLength);
switch (DC_get_desc_type(desc))
{
case SQL_ATTR_APP_ROW_DESC:
RETCODE ret = SQL_SUCCESS;
DescriptorClass *desc = (DescriptorClass *) DescriptorHandle;
- MYLOG(0, "%s h=%p(%d) rec=%d field=%d val=%p,%d\n", func, DescriptorHandle, DC_get_desc_type(desc), RecNumber, FieldIdentifier, Value, BufferLength);
+ MYLOG(0, "entering h=%p(%d) rec=%d field=%d val=%p,%d\n", DescriptorHandle, DC_get_desc_type(desc), RecNumber, FieldIdentifier, Value, BufferLength);
switch (DC_get_desc_type(desc))
{
case SQL_ATTR_APP_ROW_DESC:
CSTR func = "PGAPI_SetStmtAttr";
StatementClass *stmt = (StatementClass *) StatementHandle;
- MYLOG(0, "%s Handle=%p %d," FORMAT_ULEN "(%p)\n", func, StatementHandle, Attribute, (SQLULEN) Value, Value);
+ MYLOG(0, "entering Handle=%p %d," FORMAT_ULEN "(%p)\n", StatementHandle, Attribute, (SQLULEN) Value, Value);
switch (Attribute)
{
case SQL_ATTR_ENABLE_AUTO_IPD: /* 15 */
if (s->need_data_callback)
{
- MYLOG(0, "bulk_ope_callback in\n");
+ MYLOG(0, "entering in\n");
s->processed++;
s->idx++;
}
ConnectionClass *conn;
BindInfoClass *bookmark;
- MYLOG(0, "%s operation = %d\n", func, operationX);
+ MYLOG(0, "entering operation = %d\n", operationX);
s.stmt = (StatementClass *) hstmt;
s.operation = operationX;
SC_clear_error(s.stmt);
static SQLSMALLINT
get_interval_type(Int4 atttypmod, const char **name)
{
-MYLOG(0, "!!! %s atttypmod=%x\n", __FUNCTION__, atttypmod);
+MYLOG(0, "entering atttypmod=%x\n", atttypmod);
if ((-1) == atttypmod)
return 0;
if (0 != (YEAR_BIT & atttypmod))
int p = -1, maxsize;
const ConnInfo *ci = &(conn->connInfo);
- MYLOG(0, "%s: type=%d, atttypmod=%d, adtsize_or=%d, unknown = %d\n", __FUNCTION__, type, atttypmod, adtsize_or_longestlen, handle_unknown_size_as);
+ MYLOG(0, "entering type=%d, atttypmod=%d, adtsize_or=%d, unknown = %d\n", type, atttypmod, adtsize_or_longestlen, handle_unknown_size_as);
/* Assign Maximum size based on parameters */
switch (type)
MYLOG(1, "!!! catalog_result=%d\n", handle_unknown_size_as);
if (UNKNOWNS_AS_LONGEST == handle_unknown_size_as)
{
- MYLOG(0, "%s: LONGEST: p = %d\n", __FUNCTION__, p);
+ MYLOG(0, "LONGEST: p = %d\n", p);
if (p > 0 &&
(atttypmod < 0 || atttypmod > p))
return p;
{
Int4 default_decimal_digits = 6;
- MYLOG(0, "%s: type=%d, atttypmod=%d\n", __FUNCTION__, type, atttypmod);
+ MYLOG(0, "entering type=%d, atttypmod=%d\n", type, atttypmod);
if (atttypmod < 0 && adtsize_or_longest < 0)
return default_decimal_digits;
{
Int4 default_column_size = 28;
- MYLOG(0, "%s: type=%d, typmod=%d\n", __FUNCTION__, type, atttypmod);
+ MYLOG(0, "entering type=%d, typmod=%d\n", type, atttypmod);
if (atttypmod > -1)
return (atttypmod >> 16) & 0xffff;
static SQLSMALLINT
getTimestampDecimalDigitsX(const ConnectionClass *conn, OID type, int atttypmod)
{
- MYLOG(0, "%s: type=%d, atttypmod=%d\n", __FUNCTION__, type, atttypmod);
+ MYLOG(0, "type=%d, atttypmod=%d\n", type, atttypmod);
return (atttypmod > -1 ? atttypmod : 6);
}
{
Int4 fixed, scale;
- MYLOG(0, "%s: type=%d, atttypmod=%d\n", __FUNCTION__, type, atttypmod);
+ MYLOG(0, "entering type=%d, atttypmod=%d\n", type, atttypmod);
switch (type)
{
{
Int4 prec;
- MYLOG(0, "%s: type=%d, atttypmod=%d\n", __FUNCTION__, type, atttypmod);
+ MYLOG(0, "entering type=%d, atttypmod=%d\n", type, atttypmod);
if ((atttypmod & SECOND_BIT) == 0)
return 0;
{
Int4 ttl, leading_precision = 9, scale;
- MYLOG(0, "%s: type=%d, atttypmod=%d\n", __FUNCTION__, type, atttypmod);
+ MYLOG(0, "entering type=%d, atttypmod=%d\n", type, atttypmod);
ttl = leading_precision;
switch (get_interval_type(atttypmod, NULL))
QR_set_num_fields(QResultClass *self, int new_num_fields)
{
if (!self) return;
- MYLOG(0, "in QR_set_num_fields\n");
+ MYLOG(0, "entering\n");
CI_set_num_fields(QR_get_fields(self), new_num_fields);
- MYLOG(0, "exit QR_set_num_fields\n");
+ MYLOG(0, "leaving\n");
}
QR_inc_rowstart_in_cache(QResultClass *self, SQLLEN base_inc)
{
if (!QR_has_valid_base(self))
- MYLOG(0, "QR_inc_rowstart_in_cache called while the cache is not ready\n");
+ MYLOG(0, " called while the cache is not ready\n");
self->base += base_inc;
if (QR_synchronize_keys(self))
self->key_base = self->base;
{
QResultClass *rv;
- MYLOG(0, "in QR_Constructor\n");
+ MYLOG(0, "entering\n");
rv = (QResultClass *) malloc(sizeof(QResultClass));
if (rv != NULL)
rv->deleted_keyset = NULL;
}
- MYLOG(0, "exit QR_Constructor\n");
+ MYLOG(0, "leaving\n");
return rv;
}
BOOL top = TRUE;
if (!self) return;
- MYLOG(0, "QResult: in QR_close_result\n");
+ MYLOG(0, "entering\n");
while(self)
{
top = FALSE;
}
- MYLOG(0, "QResult: exit close_result\n");
+ MYLOG(0, "leaving\n");
}
void
QR_reset_for_re_execute(QResultClass *self)
{
- MYLOG(0, "QResult: enter %s for %p\n", __FUNCTION__, self);
+ MYLOG(0, "entering for %p\n", self);
if (!self) return;
QR_close_result(self, FALSE);
/* reset flags etc */
self->sqlstate[0] = '\0';
self->messageref = NULL;
- MYLOG(0, "QResult: exit %s\n", __FUNCTION__);
+ MYLOG(0, "leaving\n");
}
void
QR_Destructor(QResultClass *self)
{
- MYLOG(0, "QResult: enter DESTRUCTOR\n");
+ MYLOG(0, "entering\n");
if (!self) return;
QR_close_result(self, TRUE);
- MYLOG(0, "QResult: exit DESTRUCTOR\n");
+ MYLOG(0, "leaving\n");
}
UInt4 num_fields;
if (!self) return NULL;
-MYLOG(1, "QR_AddNew " FORMAT_ULEN "th row(%d fields) alloc=" FORMAT_LEN "\n", self->num_cached_rows, QR_NumResultCols(self), self->count_backend_allocated);
+MYLOG(1, FORMAT_ULEN "th row(%d fields) alloc=" FORMAT_LEN "\n", self->num_cached_rows, QR_NumResultCols(self), self->count_backend_allocated);
if (num_fields = QR_NumResultCols(self), !num_fields) return NULL;
if (self->num_fields <= 0)
{
SQLLEN num_backend_rows = self->num_cached_rows;
int num_fields = self->num_fields;
- MYLOG(0, "QResult: free memory in, fcount=" FORMAT_LEN "\n", num_backend_rows);
+ MYLOG(0, "entering fcount=" FORMAT_LEN "\n", num_backend_rows);
if (self->backend_tuples)
{
self->cursTuple = -1;
self->pstatus = 0;
- MYLOG(0, "QResult: free memory out\n");
+ MYLOG(0, "leaving\n");
}
BOOL
QR_from_PGresult(QResultClass *self, StatementClass *stmt, ConnectionClass *conn, const char *cursor, PGresult **pgres)
{
- CSTR func = "QR_from_PGResult";
int num_io_params, num_cached_rows;
int i;
Int2 paramType;
if (new_atttypmod < 0)
new_atttypmod = -1;
- MYLOG(0, "%s: fieldname='%s', adtid=%d, adtsize=%d, atttypmod=%d (rel,att)=(%d,%d)\n", func, new_field_name, new_adtid, new_adtsize, new_atttypmod, new_relid, new_attid);
+ MYLOG(0, "fieldname='%s', adtid=%d, adtsize=%d, atttypmod=%d (rel,att)=(%d,%d)\n", new_field_name, new_adtid, new_adtsize, new_atttypmod, new_relid, new_attid);
QLOG(1, "\tfieldname='%s', adtid=%d, adtsize=%d, atttypmod=%d (rel,att)=(%d,%d)\n", new_field_name, new_adtid, new_adtsize, new_atttypmod, new_relid, new_attid);
CI_set_field_info(QR_get_fields(self), lf, new_field_name, new_adtid, new_adtsize, new_atttypmod, new_relid, new_attid);
if (SQL_PARAM_OUTPUT == paramType ||
SQL_PARAM_INPUT_OUTPUT == paramType)
{
-MYLOG(1, "!![%d].PGType %u->%u\n", i, PIC_get_pgtype(ipdopts->parameters[i]), CI_get_oid(QR_get_fields(self), cidx));
+MYLOG(1, "[%d].PGType %u->%u\n", i, PIC_get_pgtype(ipdopts->parameters[i]), CI_get_oid(QR_get_fields(self), cidx));
PIC_set_pgtype(ipdopts->parameters[i], CI_get_oid(QR_get_fields(self), cidx));
cidx++;
}
CC_does_autocommit(conn) &&
CC_cursor_count(conn) <= 1)
{
- MYLOG(0, "QResult: END transaction on conn=%p\n", conn);
+ MYLOG(0, "End transaction on conn=%p\n", conn);
if ((ROLLBACK_ON_ERROR & flag) == 0)
{
STRCAT_FIXED(buf, ";commit");
does_commit = TRUE;
}
-MYLOG(1, " !!!! %s:Case I CC_send_query %s flag=%x\n", __FUNCTION__, buf, flag);
+MYLOG(1, " Case I CC_send_query %s flag=%x\n", buf, flag);
res = CC_send_query(conn, buf, NULL, flag, NULL);
QR_Destructor(res);
if (does_commit)
/* End the transaction if there are no cursors left on this conn */
if (CC_does_autocommit(conn) && CC_cursor_count(conn) == 0)
{
- MYLOG(0, "QResult: END transaction on conn=%p\n", conn);
+ MYLOG(0, "End transaction on conn=%p\n", conn);
if (!CC_commit(conn))
{
BOOL haskeyset = QR_haskeyset(self);
SQLULEN num_total_rows = QR_get_num_total_tuples(self);
-MYLOG(1, "QR_get_tupledata %p->num_fields=%d\n", self, self->num_fields);
+MYLOG(1, "entering %p->num_fields=%d\n", self, self->num_fields);
if (!QR_get_cursor(self))
{
RETURN(-1)
}
/* return a row from cache */
- MYLOG(0, "%s: fetch_number < fcount: returning tuple " FORMAT_LEN ", fcount = " FORMAT_LEN "\n", func, fetch_number, num_backend_rows);
+ MYLOG(0, "fetch_number < fcount: returning tuple " FORMAT_LEN ", fcount = " FORMAT_LEN "\n", fetch_number, num_backend_rows);
self->tupleField = the_tuples + (fetch_number * num_fields);
MYLOG(1, "tupleField=%p\n", self->tupleField);
/* move to next row */
if (!QR_get_cursor(self))
{
- MYLOG(0, "%s: ALL_ROWS: done, fcount = " FORMAT_ULEN ", fetch_number = " FORMAT_LEN "\n", func, QR_get_num_total_tuples(self), fetch_number);
+ MYLOG(0, "ALL_ROWS: done, fcount = " FORMAT_ULEN ", fetch_number = " FORMAT_LEN "\n", QR_get_num_total_tuples(self), fetch_number);
self->tupleField = NULL;
QR_set_reached_eof(self);
RETURN(-1) /* end of tuples */
"fetch %d in \"%s\"",
fetch_size, QR_get_cursor(self));
- MYLOG(0, "%s: sending actual fetch (%d) query '%s'\n", func, fetch_size, fetch);
+ MYLOG(0, "sending actual fetch (%d) query '%s'\n", fetch_size, fetch);
if (!boundary_adjusted)
{
QR_set_num_cached_rows(self, 0);
curr_eof = reached_eof_now = (QR_once_reached_eof(self) && self->cursTuple >= (Int4)self->num_total_read);
MYLOG(1, "reached_eof_now=%d\n", reached_eof_now);
- MYLOG(0, "_%s: PGresult: fetch_total = " FORMAT_ULEN " & this_fetch = " FORMAT_ULEN "\n", func, self->num_total_read, self->num_cached_rows);
- MYLOG(0, "_%s: PGresult: cursTuple = " FORMAT_LEN ", offset = " FORMAT_LEN "\n", func, self->cursTuple, offset);
+ MYLOG(0, ": PGresult: fetch_total = " FORMAT_ULEN " & this_fetch = " FORMAT_ULEN "\n", self->num_total_read, self->num_cached_rows);
+ MYLOG(0, ": PGresult: cursTuple = " FORMAT_LEN ", offset = " FORMAT_LEN "\n", self->cursTuple, offset);
cur_fetch = self->num_cached_rows - num_rows_in;
if (!ret)
num_backend_rows = self->num_cached_rows;
if (reached_eof_now)
{
- MYLOG(0, "%s: reached eof now\n", func);
+ MYLOG(0, "reached eof now\n");
QR_set_reached_eof(self);
if (self->ad_count > 0 && cur_fetch < fetch_size)
{
else
{
/* We are surely done here (we read 0 tuples) */
- MYLOG(0, "_%s: 'C': DONE (fcount == " FORMAT_LEN ")\n", func, num_backend_rows);
+ MYLOG(0, " 'C': DONE (fcount == " FORMAT_LEN ")\n", num_backend_rows);
ret = -1; /* end of tuples */
}
}
LEAVE_CONN_CS(conn);
#undef RETURN
#undef return
-MYLOG(1, "%s returning %d offset=" FORMAT_LEN "\n", func, ret, offset);
+MYLOG(1, "returning %d offset=" FORMAT_LEN "\n", ret, offset);
return ret;
}
StatementClass *stmt = (StatementClass *) hstmt;
QResultClass *res;
- MYLOG(0, "%s: entering...\n", func);
+ MYLOG(0, "entering...\n");
if (!stmt)
{
SC_log_error(func, NULL_STRING, NULL);
if (res->recent_processed_row_count >= 0)
{
*pcrow = res->recent_processed_row_count;
- MYLOG(0, "**** %s: THE ROWS: *pcrow = " FORMAT_LEN "\n", func, *pcrow);
+ MYLOG(0, "**** THE ROWS: *pcrow = " FORMAT_LEN "\n", *pcrow);
return SQL_SUCCESS;
}
num_fields = SC_describe(stmt);
result = SC_get_Curres(stmt);
- MYLOG(0, "%s: result = %p, status = %d, numcols = %d\n", func, result, stmt->status, result != NULL ? QR_NumResultCols(result) : -1);
+ MYLOG(0, "entering result = %p, status = %d, numcols = %d\n", result, stmt->status, result != NULL ? QR_NumResultCols(result) : -1);
/****if ((!result) || ((stmt->status != STMT_FINISHED) && (stmt->status != STMT_PREMATURE))) ****/
if (!QR_command_maybe_successful(result) || num_fields < 0)
{
char parse_ok;
RETCODE ret = SQL_SUCCESS;
- MYLOG(0, "%s: entering...\n", func);
+ MYLOG(0, "entering...\n");
if (!stmt)
{
SC_log_error(func, NULL_STRING, NULL);
{
if (SC_parsed_status(stmt) == STMT_PARSE_NONE)
{
- MYLOG(0, "%s: calling parse_statement on stmt=%p\n", func, stmt);
+ MYLOG(0, "calling parse_statement on stmt=%p\n", stmt);
parse_statement(stmt, FALSE);
}
{
parse_ok = TRUE;
*pccol = SC_get_IRDF(stmt)->nfields;
- MYLOG(0, "PARSE: %s: *pccol = %d\n", func, *pccol);
+ MYLOG(0, "PARSE: *pccol = %d\n", *pccol);
}
}
int len = 0;
RETCODE result = SQL_SUCCESS;
- MYLOG(0, "%s: entering.%d..\n", func, icol);
+ MYLOG(0, "entering.%d..\n", icol);
if (!stmt)
{
{
if (SC_parsed_status(stmt) == STMT_PARSE_NONE)
{
- MYLOG(0, "%s: calling parse_statement on stmt=%p\n", func, stmt);
+ MYLOG(0, "calling parse_statement on stmt=%p\n", stmt);
parse_statement(stmt, FALSE);
}
- MYLOG(0, "PARSE: DescribeCol: icol=%d, stmt=%p, stmt->nfld=%d, stmt->fi=%p\n", icol, stmt, irdflds->nfields, irdflds->fi);
+ MYLOG(0, "PARSE: icol=%d, stmt=%p, stmt->nfld=%d, stmt->fi=%p\n", icol, stmt, irdflds->nfields, irdflds->fi);
if (SC_parsed_status(stmt) != STMT_PARSE_FATAL && irdflds->fi)
{
result = SQL_ERROR;
goto cleanup;
}
- MYLOG(0, "DescribeCol: getting info for icol=%d\n", icol);
+ MYLOG(0, "getting info for icol=%d\n", icol);
}
}
decimal_digits = pgtype_decimal_digits(stmt, fieldtype, icol);
}
- MYLOG(0, "describeCol: col %d fieldname = '%s'\n", icol, NULL_IF_NULL(col_name));
- MYLOG(0, "describeCol: col %d fieldtype = %d\n", icol, fieldtype);
- MYLOG(0, "describeCol: col %d column_size = " FORMAT_LEN "\n", icol, column_size);
+ MYLOG(0, "col %d fieldname = '%s'\n", icol, NULL_IF_NULL(col_name));
+ MYLOG(0, "col %d fieldtype = %d\n", icol, fieldtype);
+ MYLOG(0, "col %d column_size = " FORMAT_LEN "\n", icol, column_size);
result = SQL_SUCCESS;
{
*pfSqlType = pgtype_to_concise_type(stmt, fieldtype, icol, unknown_sizes);
- MYLOG(0, "describeCol: col %d *pfSqlType = %d\n", icol, *pfSqlType);
+ MYLOG(0, "col %d *pfSqlType = %d\n", icol, *pfSqlType);
}
/*
*pcbColDef = column_size;
- MYLOG(0, "describeCol: col %d *pcbColDef = " FORMAT_ULEN "\n", icol, *pcbColDef);
+ MYLOG(0, "Col: col %d *pcbColDef = " FORMAT_ULEN "\n", icol, *pcbColDef);
}
/*
decimal_digits = 0;
*pibScale = (SQLSMALLINT) decimal_digits;
- MYLOG(0, "describeCol: col %d *pibScale = %d\n", icol, *pibScale);
+ MYLOG(0, "col %d *pibScale = %d\n", icol, *pibScale);
}
/*
else
*pfNullable = fi ? fi->nullable : pgtype_nullable(conn, fieldtype);
- MYLOG(0, "describeCol: col %d *pfNullable = %d\n", icol, *pfNullable);
+ MYLOG(0, "col %d *pfNullable = %d\n", icol, *pfNullable);
}
cleanup:
QResultClass *res;
BOOL stmt_updatable;
- MYLOG(0, "%s: entering..col=%d %d len=%d.\n", func, icol, fDescType,
+ MYLOG(0, "entering..col=%d %d len=%d.\n", icol, fDescType,
cbDescMax);
if (!stmt)
{
if (SC_parsed_status(stmt) == STMT_PARSE_NONE)
{
- MYLOG(0, "%s: calling parse_statement\n", func);
+ MYLOG(0, "calling parse_statement\n");
parse_statement(stmt, FALSE);
}
field_type = getEffectiveOid(conn, fi);
}
- MYLOG(0, "colAttr: col %d field_type=%d fi,ti=%p,%p\n", col_idx, field_type, fi, ti);
+ MYLOG(0, "col %d field_type=%d fi,ti=%p,%p\n", col_idx, field_type, fi, ti);
#ifdef SUPPRESS_LONGEST_ON_CURSORS
if (UNKNOWNS_AS_LONGEST == unknown_sizes)
case SQL_COLUMN_DISPLAY_SIZE: /* == SQL_DESC_DISPLAY_SIZE */
value = (USE_FI(fi, unknown_sizes) && 0 != fi->display_size) ? fi->display_size : pgtype_display_size(stmt, field_type, col_idx, unknown_sizes);
- MYLOG(0, "%s: col %d, display_size= " FORMAT_LEN "\n", func, col_idx, value);
+ MYLOG(0, "col %d, display_size= " FORMAT_LEN "\n", col_idx, value);
break;
{
p = GET_NAME(fi->column_alias);
- MYLOG(0, "%s: COLUMN_LABEL = '%s'\n", func, p);
+ MYLOG(0, "COLUMN_LABEL = '%s'\n", p);
break;
}
/* otherwise same as column name -- FALL THROUGH!!! */
MYPRINTF(1, "NULL\n");
p = fi ? (NAME_IS_NULL(fi->column_alias) ? SAFE_NAME(fi->column_name) : GET_NAME(fi->column_alias)) : QR_get_fieldname(res, col_idx);
- MYLOG(0, "%s: COLUMN_NAME = '%s'\n", func, p);
+ MYLOG(0, "COLUMN_NAME = '%s'\n", p);
break;
case SQL_COLUMN_LENGTH:
/* if (-1 == value) I'm not sure which is right */
value = 0;
- MYLOG(0, "%s: col %d, column_length = " FORMAT_LEN "\n", func, col_idx, value);
+ MYLOG(0, "col %d, column_length = " FORMAT_LEN "\n", col_idx, value);
break;
case SQL_COLUMN_MONEY: /* == SQL_DESC_FIXED_PREC_SCALE */
case SQL_COLUMN_OWNER_NAME: /* == SQL_DESC_SCHEMA_NAME */
p = ti ? SAFE_NAME(ti->schema_name) : NULL_STRING;
- MYLOG(0, "%s: SCHEMA_NAME = '%s'\n", func, p);
+ MYLOG(0, "SCHEMA_NAME = '%s'\n", p);
break;
case SQL_COLUMN_PRECISION: /* in 2.x */
if (value < 0)
value = 0;
- MYLOG(0, "%s: col %d, column_size = " FORMAT_LEN "\n", func, col_idx, value);
+ MYLOG(0, "col %d, column_size = " FORMAT_LEN "\n", col_idx, value);
break;
case SQL_COLUMN_QUALIFIER_NAME: /* == SQL_DESC_CATALOG_NAME */
case SQL_COLUMN_TABLE_NAME: /* == SQL_DESC_TABLE_NAME */
p = ti ? SAFE_NAME(ti->table_name) : NULL_STRING;
- MYLOG(0, "%s: TABLE_NAME = '%s'\n", func, p);
+ MYLOG(0, "TABLE_NAME = '%s'\n", p);
break;
case SQL_COLUMN_TYPE: /* == SQL_DESC_CONCISE_TYPE */
p = fi ? SAFE_NAME(fi->column_name) : QR_get_fieldname(res, col_idx);
- MYLOG(0, "%s: BASE_COLUMN_NAME = '%s'\n", func, p);
+ MYLOG(0, "BASE_COLUMN_NAME = '%s'\n", p);
break;
case SQL_DESC_BASE_TABLE_NAME: /* the same as TABLE_NAME ok ? */
p = ti ? SAFE_NAME(ti->table_name) : NULL_STRING;
- MYLOG(0, "%s: BASE_TABLE_NAME = '%s'\n", func, p);
+ MYLOG(0, "BASE_TABLE_NAME = '%s'\n", p);
break;
case SQL_DESC_LENGTH: /* different from SQL_COLUMN_LENGTH */
value = (fi && column_size > 0) ? column_size : pgtype_desclength(stmt, field_type, col_idx, unknown_sizes);
if (-1 == value)
value = 0;
- MYLOG(0, "%s: col %d, desc_length = " FORMAT_LEN "\n", func, col_idx, value);
+ MYLOG(0, "col %d, desc_length = " FORMAT_LEN "\n", col_idx, value);
break;
case SQL_DESC_OCTET_LENGTH:
value = (USE_FI(fi, unknown_sizes) && fi->length > 0) ? fi->length : pgtype_attr_transfer_octet_length(conn, field_type, column_size, unknown_sizes);
if (-1 == value)
value = 0;
- MYLOG(0, "%s: col %d, octet_length = " FORMAT_LEN "\n", func, col_idx, value);
+ MYLOG(0, "col %d, octet_length = " FORMAT_LEN "\n", col_idx, value);
break;
case SQL_DESC_PRECISION: /* different from SQL_COLUMN_PRECISION */
if (value = FI_precision(fi), value <= 0)
if (value < 0)
value = 0;
- MYLOG(0, "%s: col %d, desc_precision = " FORMAT_LEN "\n", func, col_idx, value);
+ MYLOG(0, "col %d, desc_precision = " FORMAT_LEN "\n", col_idx, value);
break;
case SQL_DESC_SCALE: /* different from SQL_COLUMN_SCALE */
value = pgtype_scale(stmt, field_type, col_idx);
SC_set_SS_columnkey(stmt);
}
value = fi->columnkey;
- MYLOG(0, "%s:SS_COLUMN_KEY=" FORMAT_LEN "\n", func, value);
+ MYLOG(0, "SS_COLUMN_KEY=" FORMAT_LEN "\n", value);
break;
}
SC_set_error(stmt, STMT_OPTION_NOT_FOR_THE_DRIVER, "this request may be for MS SQL Server", func);
SQLCHAR dum_rgb[2] = "\0\0";
#endif /* WITH_UNIXODBC */
- MYLOG(0, "%s: enter, stmt=%p icol=%d\n", func, stmt, icol);
+ MYLOG(0, "entering stmt=%p icol=%d\n", stmt, icol);
if (!stmt)
{
field_type = QR_get_field_type(res, icol);
atttypmod = QR_get_atttypmod(res, icol);
- MYLOG(0, "**** %s: icol = %d, target_type = %d, field_type = %d, value = '%s'\n", func, icol, target_type, field_type, NULL_IF_NULL(value));
+ MYLOG(0, "**** icol = %d, target_type = %d, field_type = %d, value = '%s'\n", icol, target_type, field_type, NULL_IF_NULL(value));
SC_set_current_col(stmt, icol);
cleanup:
#undef return
-MYLOG(1, "%s returning %d\n", __FUNCTION__, result);
+MYLOG(1, "leaving %d\n", result);
return result;
}
BindInfoClass *bookmark;
RETCODE retval = SQL_SUCCESS;
- MYLOG(0, "%s: stmt = %p, stmt->result= %p\n", func, stmt, stmt ? SC_get_Curres(stmt) : NULL);
+ MYLOG(0, "entering stmt = %p, stmt->result= %p\n", stmt, stmt ? SC_get_Curres(stmt) : NULL);
if (!stmt)
{
BOOL currp_is_valid, reached_eof, useCursor;
SQLLEN reqsize = rowsetSize;
- MYLOG(0, "%s: stmt=%p rowsetSize=" FORMAT_LEN "\n", func, stmt, rowsetSize);
+ MYLOG(0, "entering stmt=%p rowsetSize=" FORMAT_LEN "\n", stmt, rowsetSize);
if (!stmt)
{
}
/* Physical Row advancement occurs for each row fetched below */
- MYLOG(0, "PGAPI_ExtendedFetch: new currTuple = " FORMAT_LEN "\n", stmt->currTuple);
+ MYLOG(0, "new currTuple = " FORMAT_LEN "\n", stmt->currTuple);
truncated = error = FALSE;
RETCODE SQL_API
PGAPI_MoreResults(HSTMT hstmt)
{
- CSTR func = "PGAPI_MoreResults";
StatementClass *stmt = (StatementClass *) hstmt;
QResultClass *res;
RETCODE ret = SQL_SUCCESS;
- MYLOG(0, "%s: entering...\n", func);
+ MYLOG(0, "entering...\n");
res = SC_get_Curres(stmt);
if (res)
{
PGAPI_FreeStmt(hstmt, SQL_CLOSE);
ret = SQL_NO_DATA_FOUND;
}
- MYLOG(0, "%s: returning %d\n", func, ret);
+ MYLOG(0, "leaving %d\n", ret);
return ret;
}
if (!CC_is_in_trans(conn))
return;
-MYLOG(1, "AddRollback " FORMAT_LEN "(%u,%u) %s\n", index, keyset->blocknum, keyset->offset, dmlcode == SQL_ADD ? "ADD" : (dmlcode == SQL_UPDATE ? "UPDATE" : (dmlcode == SQL_DELETE ? "DELETE" : "REFRESH")));
+MYLOG(1, "entering " FORMAT_LEN "(%u,%u) %s\n", index, keyset->blocknum, keyset->offset, dmlcode == SQL_ADD ? "ADD" : (dmlcode == SQL_UPDATE ? "UPDATE" : (dmlcode == SQL_DELETE ? "DELETE" : "REFRESH")));
if (!res->rollback)
{
res->rb_count = 0;
{
SQLLEN i;
-MYLOG(1, "ReplaceCachedRows %p num_fields=%d num_rows=" FORMAT_LEN "\n", otuple, num_fields, num_rows);
+MYLOG(1, "entering %p num_fields=%d num_rows=" FORMAT_LEN "\n", otuple, num_fields, num_rows);
for (i = 0; i < num_fields * num_rows; i++, ituple++, otuple++)
{
if (otuple->value)
{
int i;
-MYLOG(1, "MoveCachedRows %p num_fields=%d num_rows=" FORMAT_LEN "\n", otuple, num_fields, num_rows);
+MYLOG(1, "entering %p num_fields=%d num_rows=" FORMAT_LEN "\n", otuple, num_fields, num_rows);
for (i = 0; i < num_fields * num_rows; i++, ituple++, otuple++)
{
if (otuple->value)
if (!res) return;
num_fields = res->num_fields;
-MYLOG(1, "AddAdded index=" FORMAT_LEN ", tuple=%p, num_fields=%d\n", index, tuple_added, num_fields);
+MYLOG(1, "entering index=" FORMAT_LEN ", tuple=%p, num_fields=%d\n", index, tuple_added, num_fields);
ad_count = res->ad_count;
res->ad_count++;
if (QR_get_cursor(res))
KeySet *added_keyset;
TupleField *added_tuples;
- MYLOG(0, "RemoveAdded index=" FORMAT_LEN "\n", index);
+ MYLOG(0, "entering index=" FORMAT_LEN "\n", index);
if (index < 0)
rmidx = -index - 1;
else
RemoveDeleted(res, index);
RemoveUpdated(res, index);
res->ad_count--;
- MYLOG(0, "RemoveAdded removed=1 count=%d\n", res->ad_count);
+ MYLOG(0, "removed=1 count=%d\n", res->ad_count);
}
static void
int i;
UWORD status;
- MYLOG(0, "CommitAdded res=%p\n", res);
+ MYLOG(0, "entering res=%p\n", res);
if (!res || !res->added_keyset) return;
added_keyset = res->added_keyset;
for (i = res->ad_count - 1; i >= 0; i--)
UWORD status;
Int2 num_fields = res->num_fields;
-MYLOG(1, "AddDeleted " FORMAT_ULEN "\n", index);
+MYLOG(1, "entering " FORMAT_ULEN "\n", index);
dl_count = res->dl_count;
res->dl_count++;
if (!QR_get_cursor(res))
SQLLEN *deleted, num_read = QR_get_num_total_read(res);
KeySet *deleted_keyset;
- MYLOG(0, "RemoveDeleted index=" FORMAT_LEN "\n", index);
+ MYLOG(0, "entering index=" FORMAT_LEN "\n", index);
if (index < 0)
{
midx = index;
rm_count++;
}
}
- MYLOG(0, "RemoveDeleted removed count=%d,%d\n", rm_count, res->dl_count);
+ MYLOG(0, "removed count=%d,%d\n", rm_count, res->dl_count);
}
static void
}
if (status != deleted_keyset->status)
{
-MYLOG(1, "!!Commit Deleted=" FORMAT_LEN "(%d)\n", *deleted, i);
+MYLOG(1, "Deleted=" FORMAT_LEN "(%d)\n", *deleted, i);
deleted_keyset->status = status;
}
}
int i;
UWORD status;
-MYLOG(1, "AddUpdated index=" FORMAT_LEN "\n", index);
+MYLOG(1, "entering index=" FORMAT_LEN "\n", index);
if (!stmt) return;
if (res = SC_get_Curres(stmt), !res) return;
if (!keyset) return;
static void
RemoveUpdated(QResultClass *res, SQLLEN index)
{
- MYLOG(0, "RemoveUpdated index=" FORMAT_LEN "\n", index);
+ MYLOG(0, "entering index=" FORMAT_LEN "\n", index);
RemoveUpdatedAfterTheKey(res, index, NULL);
}
SQLLEN pidx, midx, mv_count;
int i, num_fields = res->num_fields, rm_count = 0;
- MYLOG(0, "RemoveUpdatedAfterTheKey " FORMAT_LEN ",(%u,%u)\n", index, keyset ? keyset->blocknum : 0, keyset ? keyset->offset : 0);
+ MYLOG(0, "entering " FORMAT_LEN ",(%u,%u)\n", index, keyset ? keyset->blocknum : 0, keyset ? keyset->offset : 0);
if (index < 0)
{
midx = index;
rm_count++;
}
}
- MYLOG(0, "RemoveUpdatedAfter removed count=%d,%d\n", rm_count, res->up_count);
+ MYLOG(0, "removed count=%d,%d\n", rm_count, res->up_count);
}
static void
int i;
UWORD status;
- MYLOG(0, "CommitUpdated res=%p\n", res);
+ MYLOG(0, "entering res=%p\n", res);
if (!res) return;
if (!QR_get_cursor(res))
return;
KeySet *keyset;
BOOL kres_is_valid;
-MYLOG(1, "DiscardRollback\n");
+MYLOG(1, "entering\n");
if (QR_get_cursor(res))
{
CommitAdded(res);
for (i = res->rb_count - 1; i >= rollbp; i--)
{
-MYLOG(1, "UndoRollback %d(%d)\n", i, rollback[i].option);
+MYLOG(1, "do %d(%d)\n", i, rollback[i].option);
index = rollback[i].index;
if (curs)
{
const ssize_t from_pos = stmt->load_from_pos;
const char *load_stmt = stmt->load_statement;
-MYLOG(1, "%s bestitem=%s bestqual=%s\n", func, SAFE_NAME(ti->bestitem), SAFE_NAME(ti->bestqual));
+MYLOG(1, "entering bestitem=%s bestqual=%s\n", SAFE_NAME(ti->bestitem), SAFE_NAME(ti->bestqual));
initPQExpBuffer(&selstr);
#define return DONT_CALL_RETURN_FROM_HERE???
if (TI_has_subclass(ti))
BOOL use_ctid = TRUE;
BOOL idx_exist = TRUE;
- MYLOG(0, "positioned load fi=%p ti=%p\n", irdflds->fi, stmt->ti);
+ MYLOG(0, "entering fi=%p ti=%p\n", irdflds->fi, stmt->ti);
rcnt = 0;
if (count)
*count = 0;
const char *load_stmt = stmt->load_statement;
const ssize_t from_pos = stmt->load_from_pos;
-MYLOG(0, " %s in rows_per_fetch=%d limitrow=" FORMAT_LEN "\n", __FUNCTION__, rows_per_fetch, limitrow);
+MYLOG(0, "entering in rows_per_fetch=%d limitrow=" FORMAT_LEN "\n", rows_per_fetch, limitrow);
new_oid = 0;
#define return DONT_CALL_RETURN_FROM_HERE???
for (i = SC_get_rowset_start(stmt), kres_ridx = GIdx2KResIdx(i, stmt, res), rowc = 0, oid = 0;; i++, kres_ridx++)
Int4 rows_per_fetch;
BOOL create_from_scratch = (0 != flag);
- MYLOG(0, "%s\n", func);
+ MYLOG(0, "entering\n");
if (!(res = SC_get_Curres(stmt)))
{
SC_set_error(stmt, STMT_INVALID_CURSOR_STATE_ERROR, "Null statement result in SC_pos_reload_needed.", func);
QResultClass *res, *qres;
RETCODE ret = SQL_ERROR;
- MYLOG(0, "positioned new ti=%p\n", stmt->ti);
+ MYLOG(0, "entering ti=%p\n", stmt->ti);
if (!(res = SC_get_Curres(stmt)))
{
SC_set_error(stmt, STMT_INVALID_CURSOR_STATE_ERROR, "Null statement result in SC_pos_newload.", func);
if (s->updyes)
{
- MYLOG(0, "pos_update_callback in\n");
+ MYLOG(0, "entering\n");
ret = irow_update(ret, s->stmt, s->qstmt, s->global_ridx, &s->old_keyset);
MYLOG(1, "irow_update ret=%d,%d\n", ret, SC_get_errornumber(s->qstmt));
if (ret != SQL_SUCCESS)
SC_set_error(s.stmt, STMT_INVALID_CURSOR_STATE_ERROR, "Null statement result in SC_pos_update.", func);
return SQL_ERROR;
}
- MYLOG(0, "POS UPDATE " FORMAT_POSIROW "+" FORMAT_LEN " fi=%p ti=%p\n", s.irow, QR_get_rowstart_in_cache(s.res), fi, s.stmt->ti);
+ MYLOG(0, "entering " FORMAT_POSIROW "+" FORMAT_LEN " fi=%p ti=%p\n", s.irow, QR_get_rowstart_in_cache(s.res), fi, s.stmt->ti);
if (SC_update_not_ready(stmt))
parse_statement(s.stmt, TRUE); /* not preferable */
if (!SC_is_updatable(s.stmt))
BOOL idx_exist = TRUE;
char table_fqn[256];
- MYLOG(0, "POS DELETE ti=%p\n", stmt->ti);
+ MYLOG(0, "entering ti=%p\n", stmt->ti);
if (!(res = SC_get_Curres(stmt)))
{
SC_set_error(stmt, STMT_INVALID_CURSOR_STATE_ERROR, "Null statement result in SC_pos_delete.", func);
{
SQLSETPOSIROW brow_save;
- MYLOG(0, "pos_add_callback in ret=%d\n", ret);
+ MYLOG(0, "entering ret=%d\n", ret);
brow_save = s->stmt->bind_row;
s->stmt->bind_row = s->irow;
if (QR_get_cursor(s->res))
int func_cs_count = 0;
char table_fqn[256];
- MYLOG(0, "POS ADD fi=%p ti=%p\n", fi, stmt->ti);
+ MYLOG(0, "entering fi=%p ti=%p\n", fi, stmt->ti);
s.stmt = stmt;
s.irow = irow;
if (!(s.res = SC_get_Curres(s.stmt)))
SQLLEN kres_ridx, pos_ridx = 0;
ret = retcode;
- MYLOG(0, "%s: %d in\n", func, s->need_data_callback);
+ MYLOG(0, "entering %d in\n", s->need_data_callback);
if (s->need_data_callback)
{
s->processed++;
s.opts = SC_get_ARDF(s.stmt);
gdata_info = SC_get_GDTI(s.stmt);
gdata = gdata_info->gdata;
- MYLOG(0, "%s fOption=%d irow=" FORMAT_POSIROW " lock=%hu currt=" FORMAT_LEN "\n", func, s.fOption, s.irow, fLock, s.stmt->currTuple);
+ MYLOG(0, "entering fOption=%d irow=" FORMAT_POSIROW " lock=%hu currt=" FORMAT_LEN "\n", s.fOption, s.irow, fLock, s.stmt->currTuple);
if (s.stmt->options.scroll_concurrency != SQL_CONCUR_READ_ONLY)
;
else if (s.fOption != SQL_POSITION && s.fOption != SQL_REFRESH)
SC_set_error(s.stmt, STMT_ROW_OUT_OF_RANGE, "the row was deleted?", func);
ret = SQL_ERROR;
}
- MYLOG(0, "%s returning %d\n", func, ret);
+ MYLOG(0, "leaving %d\n", ret);
return ret;
}
CSTR func = "PGAPI_SetScrollOptions";
StatementClass *stmt = (StatementClass *) hstmt;
- MYLOG(0, "%s: fConcurrency=%d crowKeyset=" FORMAT_LEN " crowRowset=%d\n",
- func, fConcurrency, crowKeyset, crowRowset);
+ MYLOG(0, "entering fConcurrency=%d crowKeyset=" FORMAT_LEN " crowRowset=%d\n",
+ fConcurrency, crowKeyset, crowRowset);
SC_set_error(stmt, STMT_NOT_IMPLEMENTED_ERROR, "SetScroll option not implemeted", func);
return SQL_ERROR;
CSTR func = "PGAPI_SetCursorName";
StatementClass *stmt = (StatementClass *) hstmt;
- MYLOG(0, "%s: hstmt=%p, szCursor=%p, cbCursorMax=%d\n", func, hstmt, szCursor, cbCursor);
+ MYLOG(0, "entering hstmt=%p, szCursor=%p, cbCursorMax=%d\n", hstmt, szCursor, cbCursor);
if (!stmt)
{
size_t len = 0;
RETCODE result;
- MYLOG(0, "%s: hstmt=%p, szCursor=%p, cbCursorMax=%d, pcbCursor=%p\n", func, hstmt, szCursor, cbCursorMax, pcbCursor);
+ MYLOG(0, "entering hstmt=%p, szCursor=%p, cbCursorMax=%d, pcbCursor=%p\n", hstmt, szCursor, cbCursorMax, pcbCursor);
if (!stmt)
{
TupleField *otuple, *ituple;
SQLUSMALLINT *rowStatusArray;
- MYLOG(0, "%s in\n", __FUNCTION__);
+ MYLOG(0, "entering\n");
if (!(res = SC_get_Curres(stmt)))
{
opts->bookmark = NULL;
ret = PGAPI_ExtendedFetch(fstmt, SQL_FETCH_NEXT, 0,
&cRow, NULL, 0, size_of_rowset);
- MYLOG(0, "%s cRow=" FORMAT_ULEN "\n", __FUNCTION__, cRow);
+ MYLOG(0, "cRow=" FORMAT_ULEN "\n", cRow);
cleanup:
if (NULL != hstmt)
StatementClass *stmt;
ARDFields *ardopts;
- MYLOG(0, "%s: entering...\n", func);
+ MYLOG(0, "entering...\n");
if (!conn)
{
stmt = SC_Constructor(conn);
- MYLOG(0, "**** PGAPI_AllocStmt: hdbc = %p, stmt = %p\n", hdbc, stmt);
+ MYLOG(0, "**** : hdbc = %p, stmt = %p\n", hdbc, stmt);
if (!stmt)
{
CSTR func = "PGAPI_FreeStmt";
StatementClass *stmt = (StatementClass *) hstmt;
- MYLOG(0, "%s: entering...hstmt=%p, fOption=%hi\n", func, hstmt, fOption);
+ MYLOG(0, "entering...hstmt=%p, fOption=%hi\n", hstmt, fOption);
if (!stmt)
{
CSTR func = "SC_Destructor";
QResultClass *res = SC_get_Result(self);
- MYLOG(0, "SC_Destructor: self=%p, self->result=%p, self->hdbc=%p\n", self, res, self->hdbc);
+ MYLOG(0, "entering self=%p, self->result=%p, self->hdbc=%p\n", self, res, self->hdbc);
SC_clear_error(self);
if (STMT_EXECUTING == self->status)
{
DELETE_STMT_CS(self);
free(self);
- MYLOG(0, "SC_Destructor: EXIT\n");
+ MYLOG(0, "leaving\n");
return TRUE;
}
{
self->result = self->curres = NULL;
self->curr_param_result = 0;
- MYLOG(0, "SC_init_Result(%p)\n", self);
+ MYLOG(0, "leaving(%p)\n", self);
}
void
{
if (res != self->result)
{
- MYLOG(0, "SC_set_Result(%p, %p)\n", self, res);
+ MYLOG(0, "(%p, %p)\n", self, res);
QR_Destructor(self->result);
self->result = self->curres = res;
if (NULL != res)
*/
if (self->prepare && self->status == STMT_DESCRIBED)
{
- MYLOG(0, "SC_opencheck: self->prepare && self->status == STMT_DESCRIBED\n");
+ MYLOG(0, "self->prepare && self->status == STMT_DESCRIBED\n");
return FALSE;
}
if (res = SC_get_Curres(self), NULL != res)
CSTR func = "SC_recycle_statement";
ConnectionClass *conn;
- MYLOG(0, "%s: self= %p\n", func, self);
+ MYLOG(0, "entering self=%p\n", self);
SC_clear_error(self);
/* This would not happen */
SC_set_rowset_start(self, -1, FALSE);
SC_set_current_col(self, -1);
self->bind_row = 0;
-MYLOG(1, "%s statement=%p ommitted=0\n", func, self);
+MYLOG(1, "statement=%p ommitted=0\n", self);
self->last_fetch_count = self->last_fetch_count_include_ommitted = 0;
self->__error_message = NULL;
ssize_t *next_cmd, SQLSMALLINT * pcpar,
po_ind_t *multi_st, po_ind_t *proc_return)
{
- CSTR func = "SC_scanQueryAndCountParams";
const char *sptr, *tstr, *tag = NULL;
size_t taglen = 0;
char tchar, bchar, escape_in_literal = '\0';
SQLSMALLINT num_p;
encoded_str encstr;
- MYLOG(0, "%s: entering...\n", func);
+ MYLOG(0, "entering...\n");
num_p = 0;
if (proc_return)
*proc_return = 0;
{
Int4 num_fields = -1;
QResultClass *res;
- MYLOG(0, "SC_describe: status = %d\n", self->status);
+ MYLOG(0, "entering status = %d\n", self->status);
res = SC_get_Curres(self);
if (NULL != res)
{
StatementClass *child = stmt, *parent;
-MYLOG(1, "SC_get_ancestor in stmt=%p\n", stmt);
+MYLOG(1, "entering stmt=%p\n", stmt);
for (child = stmt, parent = child->execute_parent; parent; child = parent, parent = child->execute_parent)
{
MYLOG(1, "parent=%p\n", parent);
QResultClass *self_res;
BOOL repstate;
-MYLOG(1, "SC_set_error_from_res %p->%p check=%i\n", from_res ,self, check);
+MYLOG(1, "entering %p->%p check=%i\n", from_res ,self, check);
if (check)
{
if (0 == number) return;
QResultClass *self_res, *from_res;
BOOL repstate;
-MYLOG(1, "SC_error_copy %p->%p check=%i\n", from ,self, check);
+MYLOG(1, "entering %p->%p check=%i\n", from ,self, check);
if (self == from) return;
if (check)
{
{
PG_ErrorInfo *pgerror;
-MYLOG(1, "SC_full_error_copy %p->%p\n", from ,self);
+MYLOG(1, "entering %p->%p\n", from ,self);
if (self->__error_message)
{
free(self->__error_message);
/* TupleField *tupleField; */
-MYLOG(1, "%s statement=%p res=%p ommitted=0\n", func, self, res);
+MYLOG(1, "entering statement=%p res=%p ommitted=0\n", self, res);
self->last_fetch_count = self->last_fetch_count_include_ommitted = 0;
if (!res)
return SQL_ERROR;
return SQL_NO_DATA_FOUND;
}
- MYLOG(0, "**** %s: non-cursor_result\n", func);
+ MYLOG(0, "**** : non-cursor_result\n");
(self->currTuple)++;
}
else
retval = QR_next_tuple(res, self);
if (retval < 0)
{
- MYLOG(0, "**** %s: end_tuples\n", func);
+ MYLOG(0, "**** : end_tuples\n");
if (QR_get_cursor(res) &&
SQL_CURSOR_FORWARD_ONLY == self->options.cursor_type &&
QR_once_reached_eof(res))
result = SQL_SUCCESS;
self->last_fetch_count++;
-MYLOG(1, "%s: stmt=%p ommitted++\n", func, self);
+MYLOG(1, "stmt=%p ommitted++\n", self);
self->last_fetch_count_include_ommitted++;
opts = SC_get_ARDF(self);
if (CONN_EXECUTING == conn->status)
{
SC_set_error(self, STMT_SEQUENCE_ERROR, "Connection is already in use.", func);
- MYLOG(0, "%s: problem with connection\n", func);
+ MYLOG(0, "problem with connection\n");
goto cleanup;
}
is_in_trans = CC_is_in_trans(conn);
stmt->callbacks[stmt->num_callbacks].data = data;
stmt->num_callbacks++;
-MYLOG(1, "enqueueNeedDataCallack stmt=%p, func=%p, count=%d\n", stmt, func, stmt->num_callbacks);
+MYLOG(1, "stmt=%p, func=%p, count=%d\n", stmt, func, stmt->num_callbacks);
return stmt->num_callbacks;
}
void *data;
int i, cnt;
- MYLOG(0, "dequeueNeedDataCallback ret=%d count=%d\n", retcode, stmt->num_callbacks);
+ MYLOG(0, "entering ret=%d count=%d\n", retcode, stmt->num_callbacks);
if (SQL_NEED_DATA == retcode)
return retcode;
if (stmt->num_callbacks <= 0)
#endif /* NOT_USED */
/* 1. Bind */
- MYLOG(0, "%s: bind stmt=%p\n", func, stmt);
+ MYLOG(0, "bind stmt=%p\n", stmt);
if (!build_libpq_bind_params(stmt,
&nParams,
¶mTypes,
}
/* 2. Execute */
- MYLOG(0, "%s: execute stmt=%p\n", func, stmt);
+ MYLOG(0, "execute stmt=%p\n", stmt);
if (!SC_is_fetchcursor(stmt))
{
if (stmt->prepared == NOT_YET_PREPARED ||
}
pstmt = stmt->processed_statements;
- MYLOG(0, "%s execParams query=%s nParams=%d\n", __FUNCTION__, pstmt->query, nParams);
+ MYLOG(0, "execParams query=%s nParams=%d\n", pstmt->query, nParams);
QLOG(0, "PQexecParams: %p '%s' nParams=%d\n", conn->pqconn, pstmt->query, nParams);
pgres = PQexecParams(conn->pqconn,
pstmt->query,
plan_name = stmt->plan_name ? stmt->plan_name : NULL_STRING;
/* already prepared */
- MYLOG(0, "%s execPrepared plan=%s nParams=%d\n", __FUNCTION__, plan_name, nParams);
+ MYLOG(0, "execPrepared plan=%s nParams=%d\n", plan_name, nParams);
QLOG(0, "PQexecPrepared: %p plan=%s nParams=%d\n", conn->pqconn, plan_name, nParams);
pgres = PQexecPrepared(conn->pqconn,
plan_name, /* portal name == plan name */
CC_set_error(conn, CONNECTION_BACKEND_CRAZY, "Unexpected protocol character from backend (send_query)", func);
CC_on_abort(conn, CONN_DEAD);
- MYLOG(0, "send_query: error - %s\n", CC_get_errormsg(conn));
+ MYLOG(0, "PQexecxxxxxx: error - %s\n", CC_get_errormsg(conn));
QLOG(0, "error: - (%d) - %s\n", pgresstatus, CC_get_errormsg(conn));
break;
}
CSTR func = "ParseWithLibpq";
ConnectionClass *conn = SC_get_conn(stmt);
Int4 sta_pidx = -1, end_pidx = -1;
+ const char *cstatus;
Oid *paramTypes = NULL;
BOOL retval = FALSE;
PGresult *pgres = NULL;
- MYLOG(0, "%s: plan_name=%s query=%s\n", func, plan_name, query);
+ MYLOG(0, "entering plan_name=%s query=%s\n", plan_name, query);
if (!RequestStart(stmt, conn, func))
return FALSE;
handle_pgres_error(conn, pgres, "ParseWithlibpq", res, TRUE);
goto cleanup;
}
- QLOG(0, "\tok: - 'C' - %s\n", PQcmdStatus(pgres));
-MYLOG(0, "PQprepare was successful, plan=%s\n", plan_name ? plan_name : "");
+ cstatus = PQcmdStatus(pgres);
+ QLOG(0, "\tok: - 'C' - %s\n", cstatus);
+ MYLOG(0, "\tok: - 'C' - %s\n", cstatus);
if (stmt->plan_name)
SC_set_prepared(stmt, PREPARED_PERMANENTLY);
else
Oid oid;
SQLSMALLINT paramType;
- MYLOG(0, "%s: plan_name=%s query=%s\n", func, plan_name, query_param);
+ MYLOG(0, "entering plan_name=%s query=%s\n", plan_name, query_param);
if (!RequestStart(stmt, conn, func))
return NULL;
goto cleanup;
/* Describe */
- MYLOG(0, "%s: describing plan_name=%s\n", func, plan_name);
+ MYLOG(0, "describing plan_name=%s\n", plan_name);
QLOG(0, "\tPQdescribePrepared: %p plan_name=%s\n", conn->pqconn, plan_name);
pgres = PQdescribePrepared(conn->pqconn, plan_name);
CC_set_error(conn, CONNECTION_BACKEND_CRAZY, "Unexpected result from PQdescribePrepared", func);
CC_on_abort(conn, CONN_DEAD);
- MYLOG(0, "send_query: error - %s\n", CC_get_errormsg(conn));
+ MYLOG(0, "PQdescribePrepared: error - %s\n", CC_get_errormsg(conn));
goto cleanup;
}
cpylen = sizeof(pg_bm);
else if (*used >= 12)
cpylen = 12;
- MYLOG(0, "%s used=" FORMAT_LEN " cpylen=" FORMAT_SIZE_T "\n", __FUNCTION__, *used, cpylen);
+ MYLOG(0, "used=" FORMAT_LEN " cpylen=" FORMAT_SIZE_T "\n", *used, cpylen);
}
memcpy(&pg_bm, CALC_BOOKMARK_ADDR(bookmark, offset, bind_size, idx), cpylen);
-MYLOG(0, "%s index=%d block=%d off=%d\n", __FUNCTION__, pg_bm.index, pg_bm.keys.blocknum, pg_bm.keys.offset);
+MYLOG(0, "index=%d block=%d off=%d\n", pg_bm.index, pg_bm.keys.blocknum, pg_bm.keys.offset);
pg_bm.index = SC_resolve_int4_bookmark(pg_bm.index);
return pg_bm;
size_t cvtlen = sizeof(Int4);
PG_BM pg_bm;
-MYLOG(0, "%s type=%d buflen=" FORMAT_LEN " buf=%p\n", __FUNCTION__, bookmark->returntype, bookmark->buflen, bookmark->buffer);
+MYLOG(0, "entering type=%d buflen=" FORMAT_LEN " buf=%p\n", bookmark->returntype, bookmark->buflen, bookmark->buffer);
memset(&pg_bm, 0, sizeof(pg_bm));
if (SQL_C_BOOKMARK == bookmark->returntype)
;
used = LENADDR_SHIFT(used, bind_row * sizeof(SQLLEN));
*used = cvtlen;
}
-MYLOG(0, "%s cvtlen=" FORMAT_SIZE_T " ix(bl,of)=%d(%d,%d)\n", __FUNCTION__, cvtlen, pg_bm.index, pg_bm.keys.blocknum, pg_bm.keys.offset);
+MYLOG(0, "leaving cvtlen=" FORMAT_SIZE_T " ix(bl,of)=%d(%d,%d)\n", cvtlen, pg_bm.index, pg_bm.keys.blocknum, pg_bm.keys.offset);
return COPY_OK;
}
'\0' == cdt[2] &&
'\0' == cdt[3])
{
- MYLOG(0, " %s:UTF-16LE detected\n", __FUNCTION__);
+ MYLOG(0, " UTF-16LE detected\n");
convtype = WCSTYPE_UTF16_LE;
use_wcs = TRUE;
}
'\0' == cdt[6] &&
'\0' == cdt[7])
{
- MYLOG(0, " %s:UTF32-LE detected\n", __FUNCTION__);
+ MYLOG(0, " UTF32-LE detected\n");
convtype = WCSTYPE_UTF32_LE;
use_wcs = TRUE;
}
'\0' == cdt[2] &&
'\0' == cdt[3])
{
- MYLOG(0, " %s:C16_UTF-16LE detected\n", __FUNCTION__);
+ MYLOG(0, " C16_UTF-16LE detected\n");
convtype = C16TYPE_UTF16_LE;
use_c16 = TRUE;
}
{
char * utf8str;
int len = 0;
-MYLOG(0, "ucs2_to_utf8 %p ilen=" FORMAT_LEN " ", ucs2str, ilen);
+MYLOG(0, "%p ilen=" FORMAT_LEN " ", ucs2str, ilen);
if (!ucs2str)
{
if (olen)
*olen = len;
}
-MYPRINTF(0, " %s:olen=%d utf8str=%s\n", __FUNCTION__, len, utf8str ? utf8str : "");
+MYPRINTF(0, " olen=%d utf8str=%s\n", len, utf8str ? utf8str : "");
return utf8str;
}
SQLULEN rtn, ocount, wcode;
const UCHAR *str;
-MYLOG(1, "utf8_to_ucs2 ilen=" FORMAT_LEN " bufcount=" FORMAT_ULEN, ilen, bufcount);
+MYLOG(1, "ilen=" FORMAT_LEN " bufcount=" FORMAT_ULEN, ilen, bufcount);
if (!utf8str)
return 0;
MYPRINTF(1, " string=%s", utf8str);
{
char * utf8str;
int len = 0;
-MYLOG(0, " %s:%p ilen=" FORMAT_LEN "\n", __FUNCTION__, ucs4str, ilen);
+MYLOG(0, " %p ilen=" FORMAT_LEN "\n", ucs4str, ilen);
if (!ucs4str)
{
((byte4_mask2 & *wstr) >> 4) |
((byte4_mask3 & *wstr) << 10) |
((byte4_mask4 & *wstr) << 24);
-/* MYLOG(0, " %s:%08x->%08x\n", __FUNCTION__, *wstr, byte4code); */
+/* MYLOG(0, " %08x->%08x\n", *wstr, byte4code); */
if (little_endian)
memcpy(utf8str + len, (char *) &byte4code, sizeof(byte4code));
else
if (olen)
*olen = len;
}
-MYLOG(0, " %s:olen=%d %s\n", __FUNCTION__, len, utf8str ? utf8str : "");
+MYLOG(0, " olen=%d %s\n", len, utf8str ? utf8str : "");
return utf8str;
}
SQLULEN rtn, ocount, wcode;
const UCHAR *str;
-MYLOG(0, " %s:ilen=" FORMAT_LEN " bufcount=" FORMAT_ULEN "\n", __FUNCTION__, ilen, bufcount);
+MYLOG(0, " ilen=" FORMAT_LEN " bufcount=" FORMAT_ULEN "\n", ilen, bufcount);
if (!utf8str)
return 0;
MYLOG(99, " string=%s\n", utf8str);
}
if (ocount < bufcount && ucs4str)
ucs4str[ocount] = 0;
-MYLOG(0, " %s:ocount=" FORMAT_ULEN "\n", __FUNCTION__, ocount);
+MYLOG(0, " ocount=" FORMAT_ULEN "\n", ocount);
return rtn;
}
UCHAR * const udt = (UCHAR *) &dmy_wchar;
unsigned int uintdt;
-MYLOG(0, " %s:ilen=" FORMAT_LEN " bufcount=%d\n", __FUNCTION__, ilen, bufcount);
+MYLOG(0, " ilen=" FORMAT_LEN " bufcount=%d\n", ilen, bufcount);
if (ilen < 0)
ilen = ucs4strlen(ucs4str);
for (i = 0; i < ilen && (uintdt = ucs4str[i]); i++)
unsigned int dmy_uint;
UCHAR * const udt = (UCHAR *) &dmy_uint;
-MYLOG(0, " %s:ilen=" FORMAT_LEN " bufcount=%d\n", __FUNCTION__, ilen, bufcount);
+MYLOG(0, " ilen=" FORMAT_LEN " bufcount=%d\n", ilen, bufcount);
if (ilen < 0)
ilen = ucs2strlen(ucs2str);
udt[3] = 0; /* always */
{
int outlen = -1;
-MYLOG(0, " %s:inmsg=%p buflen=%d\n", __FUNCTION__, inmsg, buflen);
+MYLOG(0, " inmsg=%p buflen=%d\n", inmsg, buflen);
#ifdef WIN32
if (NULL == outmsg)
buflen = 0;
if (outmsg && outlen >= buflen)
{
outmsg[buflen - 1] = 0;
- MYLOG(0, " %s:out=%dchars truncated to %d\n", __FUNCTION__, outlen, buflen - 1);
+ MYLOG(0, " out=%dchars truncated to %d\n", outlen, buflen - 1);
}
-MYLOG(0, " %s buf=%dchars out=%dchars\n", __FUNCTION__, buflen, outlen);
+MYLOG(0, " buf=%dchars out=%dchars\n", buflen, outlen);
return outlen;
}
{
int outlen = -1;
-MYLOG(0, " %s:wstr=%p buflen=%d\n", __FUNCTION__, wstr, buflen);
+MYLOG(0, " wstr=%p buflen=%d\n", wstr, buflen);
#ifdef WIN32
if (NULL == outmsg)
buflen = 0;
if (outmsg && outlen >= buflen)
{
outmsg[buflen - 1] = 0;
- MYLOG(0, " %s:out=%dbytes truncated to %d\n", __FUNCTION__, outlen, buflen - 1);
+ MYLOG(0, " out=%dbytes truncated to %d\n", outlen, buflen - 1);
}
-MYLOG(0, " %s buf=%dbytes outlen=%dbytes\n", __FUNCTION__, buflen, outlen);
+MYLOG(0, " buf=%dbytes outlen=%dbytes\n", buflen, outlen);
return outlen;
}
const char *cdt;
mbstate_t mbst = initial_state;
-MYLOG(0, " %s:c16dt=%p size=%lu\n", __FUNCTION__, c16dt, n);
+MYLOG(0, " c16dt=%p size=%lu\n", c16dt, n);
for (i = 0, cdt = c8dt; i < n || (!c16dt); i++)
{
if (lf_conv && PG_LINEFEED == *cdt && i > 0 && PG_CARRIAGE_RETURN != cdt[-1])
char *cdt, c4byte[4];
mbstate_t mbst = initial_state;
-MYLOG(0, " %s:c8dt=%p size=%lu\n", __FUNCTION__, c8dt, n);
+MYLOG(0, " c8dt=%p size=%lu\n", c8dt, n);
if (!c8dt)
n = 0;
for (i = 0, cdt = c8dt; c16dt[i] && (result < n || (!cdt)); i++)
}
get_convtype();
- MYLOG(0, " %s\n", __FUNCTION__);
+ MYLOG(0, " \n");
#if defined(__WCS_ISO10646__)
if (use_wcs)
{
}
get_convtype();
-MYLOG(0, " %s\n", __FUNCTION__);
+MYLOG(0, "\n");
#if defined(__WCS_ISO10646__)
if (use_wcs)
{
SQLLEN l = (-2);
get_convtype();
- MYLOG(0, " %s:lf_conv=%d\n", __FUNCTION__, lf_conv);
+ MYLOG(0, " lf_conv=%d\n", lf_conv);
#if defined(__WCS_ISO10646__)
if (use_wcs)
{
SQLLEN l = (-2);
get_convtype();
- MYLOG(0, " %s:size=" FORMAT_SIZE_T " lf_conv=%d\n", __FUNCTION__, n, lf_conv);
+ MYLOG(0, " size=" FORMAT_SIZE_T " lf_conv=%d\n", n, lf_conv);
#if defined(__WCS_ISO10646__)
if (use_wcs)
{
char *convalc = NULL;
get_convtype();
- MYLOG(0, " %s:lf_conv=%d\n", __FUNCTION__, lf_conv);
+ MYLOG(0, " lf_conv=%d\n", lf_conv);
#if defined(__WCS_ISO10646__)
if (use_wcs)
{
else if (NULL != convalc)
*wcsbuf = (char *) convalc;
-MYLOG(0, " %s:return=" FORMAT_LEN "\n", __FUNCTION__, l);
+MYLOG(0, " return=" FORMAT_LEN "\n", l);
return l;
}
SQLLEN l = (-2);
get_convtype();
- MYLOG(0, " %s:size=" FORMAT_SIZE_T "\n", __FUNCTION__, n);
+ MYLOG(0, " size=" FORMAT_SIZE_T "\n", n);
#if defined(__WCS_ISO10646__)
if (use_wcs)
{
free(*wcsbuf);
*wcsbuf = NULL;
-MYLOG(0, " %s:return=" FORMAT_LEN "\n", __FUNCTION__, l);
+MYLOG(0, " return=" FORMAT_LEN "\n", l);
return l;
}
projects / psqlodbc.git / commitdiff