Use macro MYLOG instead of function mylog in preparation for later changes and unify mylog() and inolog() using level parameter.
Enable the compiler to check the format string against the parameter of mylog() by adding __attribute__((format(printf,.,.))) to the declaration of mylog(GCC only).
Using this mechanism, check and fix many discordances of parameters.
IPDFields *ipdopts;
PutDataInfo *pdata_info;
- mylog("%s: entering...\n", func);
+ MYLOG(0, "%s: entering...\n", func);
if (!stmt)
{
if (stmt->status == STMT_DESCRIBED)
SC_recycle_statement(stmt);
- mylog("%s: ipar=%d, paramType=%d, fCType=%d, fSqlType=%d, cbColDef=%d, ibScale=%d,", func, ipar, fParamType, fCType, fSqlType, cbColDef, ibScale);
- mylog("rgbValue=%p(%d), pcbValue=%p\n", rgbValue, cbValueMax, pcbValue);
+ 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, "rgbValue=%p(" FORMAT_LEN "), pcbValue=%p\n", rgbValue, cbValueMax, pcbValue);
return SQL_SUCCESS;
}
BindInfoClass *bookmark;
RETCODE ret = SQL_SUCCESS;
- mylog("%s: entering...\n", func);
+ MYLOG(0, "%s: entering...\n", func);
- mylog("**** PGAPI_BindCol: stmt = %p, icol = %d\n", stmt, icol);
- mylog("**** : fCType=%d rgb=%p valusMax=%d pcb=%p\n", fCType, rgbValue, cbValueMax, pcbValue);
+ MYLOG(0, "**** PGAPI_BindCol: 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)
{
break;
default:
SC_set_error(stmt, STMT_PROGRAM_TYPE_OUT_OF_RANGE, "Bind column 0 is not of type SQL_C_BOOKMARK", func);
-inolog("Bind column 0 is type %d not of type SQL_C_BOOKMARK", fCType);
+MYLOG(1, "Bind column 0 is type %d not of type SQL_C_BOOKMARK", fCType);
ret = SQL_ERROR;
goto cleanup;
}
}
opts->bindings[icol].scale = 0;
- mylog(" bound buffer[%d] = %p\n", icol, opts->bindings[icol].buffer);
+ MYLOG(0, " bound buffer[%d] = %p\n", icol, opts->bindings[icol].buffer);
}
cleanup:
OID pgtype;
ConnectionClass *conn;
- mylog("%s: entering...%d\n", func, ipar);
+ MYLOG(0, "%s: entering...%d\n", func, ipar);
if (!stmt)
{
}
if ((ipar < 1) || (ipar > num_params))
{
-inolog("num_params=%d\n", stmt->num_params);
+MYLOG(1, "num_params=%d\n", stmt->num_params);
SC_set_error(stmt, STMT_BAD_PARAMETER_NUMBER_ERROR, "Invalid parameter number for PGAPI_DescribeParam.", func);
return SQL_ERROR;
}
if (NOT_YET_PREPARED == stmt->prepared)
{
decideHowToPrepare(stmt, FALSE);
-inolog("howTo=%d\n", SC_get_prepare_method(stmt));
+MYLOG(1, "howTo=%d\n", SC_get_prepare_method(stmt));
switch (SC_get_prepare_method(stmt))
{
case NAMED_PARSE_REQUEST:
/* parameter markers, not bound parameters. */
if (pfSqlType)
{
-inolog("[%d].SQLType=%d .PGType=%d\n", ipar, ipdopts->parameters[ipar].SQLType, pgtype);
+MYLOG(1, "[%d].SQLType=%d .PGType=%d\n", ipar, ipdopts->parameters[ipar].SQLType, pgtype);
if (ipdopts->parameters[ipar].SQLType)
*pfSqlType = ipdopts->parameters[ipar].SQLType;
else if (pgtype)
StatementClass *stmt = (StatementClass *) hstmt;
CSTR func = "PGAPI_NumParams";
- mylog("%s: entering...\n", func);
+ MYLOG(0, "%s: entering...\n", func);
if (!stmt)
{
SC_set_error(stmt, STMT_EXEC_ERROR, "parameter count address is null", func);
return SQL_ERROR;
}
-inolog("num_params=%d,%d\n", stmt->num_params, stmt->proc_return);
+MYLOG(1, "num_params=%d,%d\n", stmt->num_params, stmt->proc_return);
if (stmt->num_params >= 0)
*pcpar = stmt->num_params;
else if (!stmt->statement)
stmt->proc_return = proc_return;
stmt->multi_statement = multi;
}
-inolog("num_params=%d,%d\n", stmt->num_params, stmt->proc_return);
+MYLOG(1, "num_params=%d,%d\n", stmt->num_params, stmt->proc_return);
return SQL_SUCCESS;
}
CSTR func = "extend_parameter_bindings";
ParameterInfoClass *new_bindings;
- mylog("%s: entering ... self=%p, parameters_allocated=%d, num_params=%d,%p\n", func, self, self->allocated, num_params, self->parameters);
+ MYLOG(0, "%s: entering ... self=%p, parameters_allocated=%d, num_params=%d,%p\n", func, 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("%s: unable to create %d new bindings from %d old bindings\n", func, num_params, self->allocated);
+ MYLOG(0, "%s: unable to create %d new bindings from %d old bindings\n", func, num_params, self->allocated);
if (self->parameters)
free(self->parameters);
self->allocated = num_params;
}
- mylog("exit %s=%p\n", func, self->parameters);
+ MYLOG(0, "exit %s=%p\n", func, self->parameters);
}
void
CSTR func = "extend_iparameter_bindings";
ParameterImplClass *new_bindings;
- mylog("%s: entering ... self=%p, parameters_allocated=%d, num_params=%d\n", func, self, self->allocated, num_params);
+ MYLOG(0, "%s: entering ... self=%p, parameters_allocated=%d, num_params=%d\n", func, 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("%s: unable to create %d new bindings from %d old bindings\n", func, num_params, self->allocated);
+ MYLOG(0, "%s: unable to create %d new bindings from %d old bindings\n", func, num_params, self->allocated);
if (self->parameters)
free(self->parameters);
self->allocated = num_params;
}
- mylog("exit %s=%p\n", func, self->parameters);
+ MYLOG(0, "exit %s=%p\n", func, self->parameters);
}
void
{
CSTR func = "reset_a_parameter_binding";
- mylog("%s: entering ... self=%p, parameters_allocated=%d, ipar=%d\n", func, self, self->allocated, ipar);
+ MYLOG(0, "%s: entering ... self=%p, parameters_allocated=%d, ipar=%d\n", func, self, self->allocated, ipar);
if (ipar < 1 || ipar > self->allocated)
return;
{
CSTR func = "reset_a_iparameter_binding";
- mylog("%s: entering ... self=%p, parameters_allocated=%d, ipar=%d\n", func, self, self->allocated, ipar);
+ MYLOG(0, "%s: entering ... self=%p, parameters_allocated=%d, ipar=%d\n", func, self, self->allocated, ipar);
if (ipar < 1 || ipar > self->allocated)
return;
APD_free_params(APDFields *apdopts, char option)
{
CSTR func = "APD_free_params";
- mylog("%s: ENTER, self=%p\n", func, apdopts);
+ MYLOG(0, "%s: ENTER, self=%p\n", func, apdopts);
if (!apdopts->parameters)
return;
apdopts->allocated = 0;
}
- mylog("%s: EXIT\n", func);
+ MYLOG(0, "%s: EXIT\n", func);
}
void
CSTR func = "PDATA_free_params";
int i;
- mylog("%s: ENTER, self=%p\n", func, pdata);
+ MYLOG(0, "%s: ENTER, self=%p\n", func, pdata);
if (!pdata->pdata)
return;
pdata->allocated = 0;
}
- mylog("%s: EXIT\n", func);
+ MYLOG(0, "%s: EXIT\n", func);
}
/*
{
CSTR func = "IPD_free_params";
- mylog("%s: ENTER, self=%p\n", func, ipdopts);
+ MYLOG(0, "%s: ENTER, self=%p\n", func, ipdopts);
if (!ipdopts->parameters)
return;
ipdopts->allocated = 0;
}
- mylog("%s: EXIT\n", func);
+ MYLOG(0, "%s: EXIT\n", func);
}
void
BindInfoClass *new_bindings;
int i;
- mylog("%s: entering ... self=%p, bindings_allocated=%d, num_columns=%d\n", func, self, self->allocated, num_columns);
+ MYLOG(0, "%s: entering ... self=%p, bindings_allocated=%d, num_columns=%d\n", func, 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("%s: unable to create %d new bindings from %d old bindings\n", func, num_columns, self->allocated);
+ MYLOG(0, "%s: unable to create %d new bindings from %d old bindings\n", func, num_columns, self->allocated);
if (self->bindings)
{
/* SQLExecDirect(...) # returns 5 cols */
/* SQLExecDirect(...) # returns 10 cols (now OK) */
- mylog("exit %s=%p\n", func, self->bindings);
+ MYLOG(0, "exit %s=%p\n", func, self->bindings);
}
void
CSTR func = "reset_a_column_binding";
BindInfoClass *bookmark;
- mylog("%s: entering ... self=%p, bindings_allocated=%d, icol=%d\n", func, self, self->allocated, icol);
+ MYLOG(0, "%s: entering ... self=%p, bindings_allocated=%d, icol=%d\n", func, self, self->allocated, icol);
if (icol > self->allocated)
return;
{
Int2 lf;
-inolog("ARD_unbind_cols freeall=%d allocated=%d bindings=%p", freeall, self->allocated, self->bindings);
+MYLOG(1, "ARD_unbind_cols freeall=%d allocated=%d bindings=%p", freeall, self->allocated, self->bindings);
for (lf = 1; lf <= self->allocated; lf++)
reset_a_column_binding(self, lf);
if (freeall)
{
Int2 lf;
-inolog("GDATA_unbind_cols freeall=%d allocated=%d gdata=%p", freeall, self->allocated, self->gdata);
+MYLOG(1, "GDATA_unbind_cols freeall=%d allocated=%d gdata=%p", freeall, self->allocated, self->gdata);
if (self->fdata.ttlbuf)
{
free(self->fdata.ttlbuf);
CSTR func = "extend_getdata_info";
GetDataClass *new_gdata;
- mylog("%s: entering ... self=%p, gdata_allocated=%d, num_columns=%d\n", func, self, self->allocated, num_columns);
+ MYLOG(0, "%s: entering ... self=%p, gdata_allocated=%d, num_columns=%d\n", func, 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("%s: unable to create %d new gdata from %d old gdata\n", func, num_columns, self->allocated);
+ MYLOG(0, "%s: unable to create %d new gdata from %d old gdata\n", func, num_columns, self->allocated);
if (self->gdata)
{
* about it by unbinding those columns.
*/
- mylog("exit extend_gdata_info=%p\n", self->gdata);
+ MYLOG(0, "exit extend_gdata_info=%p\n", self->gdata);
}
void reset_a_getdata_info(GetDataInfo *gdata_info, int icol)
{
CSTR func = "extend_putdata_info";
PutDataClass *new_pdata;
- mylog("%s: entering ... self=%p, parameters_allocated=%d, num_params=%d\n", func, self, self->allocated, num_params);
+ MYLOG(0, "%s: entering ... self=%p, parameters_allocated=%d, num_params=%d\n", func, self, self->allocated, num_params);
/*
* if we have too few, allocate room for more, and copy the old
{
if (self->allocated <= 0 && self->pdata)
{
- mylog("??? pdata is not null while allocated == 0\n");
+ MYLOG(0, "??? pdata is not null while allocated == 0\n");
self->pdata = NULL;
}
new_pdata = (PutDataClass *) realloc(self->pdata, sizeof(PutDataClass) * num_params);
if (!new_pdata)
{
- mylog("%s: unable to create %d new pdata from %d old pdata\n", func, num_params, self->allocated);
+ MYLOG(0, "%s: unable to create %d new pdata from %d old pdata\n", func, num_params, self->allocated);
self->pdata = NULL;
self->allocated = 0;
}
}
- mylog("exit %s=%p\n", func, self->pdata);
+ MYLOG(0, "exit %s=%p\n", func, self->pdata);
}
void reset_a_putdata_info(PutDataInfo *pdata_info, int ipar)
{
/* at first read in the number of fields that are in the query */
new_num_fields = PQnfields(pgres);
- mylog("num_fields = %d\n", new_num_fields);
+ MYLOG(0, "num_fields = %d\n", new_num_fields);
if (self)
{
new_adtid = PQftype(pgres, lf);
new_adtsize = PQfsize(pgres, lf);
- mylog("READING ATTTYPMOD\n");
+ MYLOG(0, "READING ATTTYPMOD\n");
new_atttypmod = PQfmod(pgres, lf);
/* Subtract the header length */
if (new_atttypmod < 0)
new_atttypmod = -1;
- mylog("%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, "%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);
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("%s: entering...\n", func);
+ MYLOG(0, "%s: entering...\n", func);
conn = CC_Constructor();
- mylog("**** %s: henv = %p, conn = %p\n", func, henv, conn);
+ MYLOG(0, "**** %s: henv = %p, conn = %p\n", func, henv, conn);
if (!conn)
{
RETCODE ret = SQL_SUCCESS;
char fchar, *tmpstr;
- mylog("%s: entering..cbDSN=%hi.\n", func, cbDSN);
+ MYLOG(0, "%s: entering..cbDSN=%hi.\n", func, cbDSN);
if (!conn)
{
if (SQL_SUCCESS == ret && 2 == fchar)
ret = SQL_SUCCESS_WITH_INFO;
- mylog("%s: returning..%d.\n", func, ret);
+ MYLOG(0, "%s: returning..%d.\n", func, ret);
return ret;
}
CSTR func = "PGAPI_BrowseConnect";
ConnectionClass *conn = (ConnectionClass *) hdbc;
- mylog("%s: entering...\n", func);
+ MYLOG(0, "%s: entering...\n", func);
CC_set_error(conn, CONN_NOT_IMPLEMENTED_ERROR, "Function not implemented", func);
return SQL_ERROR;
CSTR func = "PGAPI_Disconnect";
- mylog("%s: entering...\n", func);
+ MYLOG(0, "%s: entering...\n", func);
if (!conn)
{
}
logs_on_off(-1, conn->connInfo.drivers.debug, conn->connInfo.drivers.commlog);
- mylog("%s: about to CC_cleanup\n", func);
+ MYLOG(0, "%s: about to CC_cleanup\n", func);
/* Close the connection and free statements */
CC_cleanup(conn, FALSE);
- mylog("%s: done CC_cleanup\n", func);
- mylog("%s: returning...\n", func);
+ MYLOG(0, "%s: done CC_cleanup\n", func);
+ MYLOG(0, "%s: returning...\n", func);
return SQL_SUCCESS;
}
CSTR func = "PGAPI_FreeConnect";
EnvironmentClass *env;
- mylog("%s: entering...\n", func);
- mylog("**** in %s: hdbc=%p\n", func, hdbc);
+ MYLOG(0, "%s: entering...\n", func);
+ MYLOG(0, "**** in %s: hdbc=%p\n", func, hdbc);
if (!conn)
{
CC_Destructor(conn);
- mylog("%s: returning...\n", func);
+ MYLOG(0, "%s: returning...\n", func);
return SQL_SUCCESS;
}
char
CC_Destructor(ConnectionClass *self)
{
- mylog("enter CC_Destructor, self=%p\n", self);
+ MYLOG(0, "enter CC_Destructor, self=%p\n", self);
if (self->status == CONN_EXECUTING)
return 0;
CC_cleanup(self, FALSE); /* cleanup socket and statements */
- mylog("after CC_Cleanup\n");
+ MYLOG(0, "after CC_Cleanup\n");
/* Free up statement holders */
if (self->stmts)
free(self->descs);
self->descs = NULL;
}
- mylog("after free statement holders\n");
+ MYLOG(0, "after free statement holders\n");
NULL_THE_NAME(self->schemaIns);
NULL_THE_NAME(self->tableIns);
DELETE_CONNLOCK(self);
free(self);
- mylog("exit CC_Destructor\n");
+ MYLOG(0, "exit CC_Destructor\n");
return 1;
}
count = 0;
QResultClass *res;
- mylog("CC_cursor_count: self=%p, num_stmts=%d\n", self, self->num_stmts);
+ MYLOG(0, "CC_cursor_count: 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("CC_cursor_count: returning %d\n", count);
+ MYLOG(0, "CC_cursor_count: returning %d\n", count);
return count;
}
if (!CC_is_in_trans(self))
{
QResultClass *res = CC_send_query(self, bgncmd, NULL, 0, NULL);
- mylog("CC_begin: sending BEGIN!\n");
+ MYLOG(0, "CC_begin: 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("CC_commit: sending COMMIT!\n");
+ MYLOG(0, "CC_commit: 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("CC_abort: sending ABORT!\n");
+ MYLOG(0, "CC_abort: sending ABORT!\n");
ret = QR_command_maybe_successful(res);
QR_Destructor(res);
}
if ((on && currsts) ||
(!on && !currsts))
return on;
- mylog("%s: %d->%d\n", func, currsts, on);
+ MYLOG(0, "%s: %d->%d\n", func, currsts, on);
if (CC_is_in_trans(self))
CC_commit(self);
if (on)
if (self->status == CONN_EXECUTING)
return FALSE;
- mylog("in CC_Cleanup, self=%p\n", self);
+ MYLOG(0, "in CC_Cleanup, self=%p\n", self);
ENTER_CONN_CS(self);
/* Cancel an ongoing transaction */
self->pqconn = NULL;
}
- mylog("after PQfinish\n");
+ MYLOG(0, "after PQfinish\n");
/* Free all the stmts on this connection */
for (i = 0; i < self->num_stmts; i++)
}
LEAVE_CONN_CS(self);
- mylog("exit CC_Cleanup\n");
+ MYLOG(0, "exit CC_Cleanup\n");
return TRUE;
}
char *errmsg = NULL;
size_t errmsglen;
- inolog("handle_pgres_error");
+ MYLOG(1, "handle_pgres_error");
if (res && pgres)
{
{
const char *errmsg = "The connection has been lost";
- mylog("%s setting error message=%s\n", __FUNCTION__, errmsg);
+ MYLOG(0, "%s setting error message=%s\n", __FUNCTION__, errmsg);
if (CC_get_errornumber(self) <= 0)
CC_set_error(self, CONNECTION_COMMUNICATION_ERROR, errmsg, comment);
if (res)
if (PG_VERSION_GE(self, 9.6))
{
errseverity_nonloc = PQresultErrorField(pgres, PG_DIAG_SEVERITY_NONLOCALIZED);
- mylog("PG_DIAG_SEVERITY_NONLOCALIZED=%s\n", errseverity_nonloc ? errseverity_nonloc : "(null)");
+ MYLOG(0, "PG_DIAG_SEVERITY_NONLOCALIZED=%s\n", errseverity_nonloc ? errseverity_nonloc : "(null)");
}
errprimary = PQresultErrorField(pgres, PG_DIAG_MESSAGE_PRIMARY);
if (errprimary == NULL)
if (!error_not_a_notice) /* warning, notice, log etc */
{
- mylog("notice message %s\n", errmsg);
+ MYLOG(0, "notice message %s\n", errmsg);
if (res)
{
if (QR_command_successful(res))
}
if (get_mylog() > 0)
- mylog("error message=%s(%d)\n", errmsg, strlen(errmsg));
+ MYLOG(0, "error message=%s(" FORMAT_SIZE_T ")\n", errmsg, strlen(errmsg));
if (res)
{
#endif /* _MSC_VER */
);
qlog(vermsg);
- mylog(vermsg);
+ MYLOG(0, "%s", vermsg);
qlog("Global Options: fetch=%d, unknown_sizes=%d, max_varchar_size=%d, max_longvarchar_size=%d\n",
ci->drivers.fetch_max,
ci->drivers.unknown_sizes,
return 0;
}
- mylog("%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, "%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" : "");
return 1;
}
CSTR func = "LIBPQ_CC_connect";
QResultClass *res;
- mylog("%s: entering...\n", func);
+ MYLOG(0, "%s: entering...\n", func);
if (0 == CC_initial_log(self, func))
return 0;
CSTR func = "CC_connect";
char ret, *saverr = NULL, retsend;
- mylog("%s: entering...\n", func);
+ MYLOG(0, "%s: entering...\n", func);
- mylog("sslmode=%s\n", self->connInfo.sslmode);
+ MYLOG(0, "sslmode=%s\n", self->connInfo.sslmode);
ret = LIBPQ_CC_connect(self, salt_para);
if (ret <= 0)
if (CC_is_in_unicode_driver(self)
&& (CC_is_in_ansi_app(self) || 0 < ci->bde_environment))
self->unicode |= CONN_DISALLOW_WCHAR;
-mylog("conn->unicode=%d Client Encoding='%s' (Code %d)\n", self->unicode, self->original_client_encoding, self->ccsc);
+MYLOG(0, "conn->unicode=%d Client Encoding='%s' (Code %d)\n", self->unicode, self->original_client_encoding, self->ccsc);
ret = 1;
cleanup:
- mylog("%s: returning...%d\n", func, ret);
+ MYLOG(0, "%s: returning...%d\n", func, ret);
if (NULL != saverr)
{
if (ret > 0 && CC_get_errornumber(self) <= 0)
int i;
char ret = TRUE;
- mylog("CC_add_statement: self=%p, stmt=%p\n", self, stmt);
+ MYLOG(0, "CC_add_statement: self=%p, stmt=%p\n", self, stmt);
CONNLOCK_ACQUIRE(self);
for (i = 0; i < self->num_stmts; i++)
{
int i;
- mylog("CC_error_statements: self=%p\n", self);
+ MYLOG(0, "CC_error_statements: self=%p\n", self);
for (i = 0; i < self->num_stmts; i++)
{
len = self->max_identifier_length = QR_get_value_backend_int(res, 0, 0, FALSE);
QR_Destructor(res);
}
-mylog("max_identifier_length=%d\n", len);
+MYLOG(0, "max_identifier_length=%d\n", len);
return len < 0 ? 0 : len;
}
if (strcmp(QR_get_fieldname(qres, 0), TRANSACTION_ISOLATION) == 0)
{
conn->server_isolation = isolation_str_to_enum(QR_get_value_backend_text(qres, 0, 0));
- mylog("isolation %d to be %d\n", conn->server_isolation, conn->isolation);
+ MYLOG(0, "isolation %d to be %d\n", conn->server_isolation, conn->isolation);
if (0 == conn->isolation)
conn->isolation = conn->server_isolation;
if (0 == conn->default_isolation)
isolation = self->server_isolation;
}
QR_Destructor(res);
-mylog("isolation=%d\n", isolation);
+MYLOG(0, "isolation=%d\n", isolation);
return isolation;
}
{
int rv;
- mylog("enter CC_get_error\n");
+ MYLOG(0, "enter CC_get_error\n");
CONNLOCK_ACQUIRE(self);
CONNLOCK_RELEASE(self);
- mylog("exit CC_get_error\n");
+ MYLOG(0, "exit CC_get_error\n");
return rv;
}
QR_set_cursor(res, NULL);
QR_Destructor(wres);
CONNLOCK_ACQUIRE(self);
-inolog(" !!!! %s:%p->permanent -> %d %p\n", __FUNCTION__, res, QR_is_permanent(res), QR_get_cursor(res));
+MYLOG(1, " !!!! %s:%p->permanent -> %d %p\n", __FUNCTION__, res, QR_is_permanent(res), QR_get_cursor(res));
}
else
QR_set_permanent(res);
CONNLOCK_RELEASE(conn);
conn->on_commit_in_progress = 0;
}
-void CC_on_abort(ConnectionClass *conn, UDWORD opt)
+void CC_on_abort(ConnectionClass *conn, unsigned int opt)
{
BOOL set_no_trans = FALSE;
-mylog("CC_on_abort in opt=%x\n", opt);
+MYLOG(0, "CC_on_abort in 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("CC_on_abort_partial in\n");
+MYLOG(0, "CC_on_abort_partial in\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(" %s:rollback_type=%d %s\n", __FUNCTION__, rollback_type, cmd);
+ MYLOG(0, " %s:rollback_type=%d %s\n", __FUNCTION__, rollback_type, 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(" %s:query_rollback PQsendQuery %s\n", __FUNCTION__, cmd);
+ MYLOG(0, " %s:query_rollback PQsendQuery %s\n", __FUNCTION__, cmd);
PQsendQuery(self->pqconn, cmd);
ret = 1;
while (self->pqconn && (pgres = PQgetResult(self->pqconn)) != NULL)
CC_set_no_error_trans(self);
}
else
- mylog(" %s:return error\n", __FUNCTION__);
+ MYLOG(0, " %s:return error\n", __FUNCTION__);
LIBPQ_update_transaction_status(self);
break;
}
if (appendq)
{
- mylog("%s_append: conn=%p, query='%s'+'%s'\n", func, self, query, appendq);
+ MYLOG(0, "%s_append: conn=%p, query='%s'+'%s'\n", func, self, query, appendq);
qlog("conn=%p, query='%s'+'%s'\n", self, query, appendq);
}
else
{
- mylog("%s: conn=%p, query='%s'\n", func, self, query);
+ MYLOG(0, "%s: conn=%p, query='%s'\n", func, self, query);
qlog("conn=%p, query='%s'\n", self, query);
}
/* append all these together, to avoid round-trips */
query_len = strlen(query);
- mylog("%s:query_len=%u\n", __FUNCTION__, query_len);
+ MYLOG(0, "%s:query_len=" FORMAT_SIZE_T "\n", __FUNCTION__, 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("!!!! %s:query_buf=%s(%d)\n", __FUNCTION__, query_buf.data, strlen(query_buf.data));
+MYLOG(1, "!!!! %s:query_buf=%s(" FORMAT_SIZE_T ")\n", __FUNCTION__, 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("send_query: ok - 'C' - %s\n", cmdbuffer);
+ MYLOG(0, "send_query: ok - 'C' - %s\n", cmdbuffer);
if (query_completed) /* allow for "show" style notices */
nrarg.res = res;
}
- mylog("send_query: setting cmdbuffer = '%s'\n", cmdbuffer);
+ MYLOG(0, "send_query: setting cmdbuffer = '%s'\n", cmdbuffer);
my_trim(cmdbuffer); /* get rid of trailing space */
if (strnicmp(cmdbuffer, bgncmd, strlen(bgncmd)) == 0)
{
discard_next_savepoint = FALSE;
discard_next_release = TRUE;
-inolog("Discarded a SAVEPOINT result\n");
+MYLOG(1, "Discarded a SAVEPOINT result\n");
break; /* discard the result */
}
if (SAVEPOINT_IN_PROGRESS == self->internal_op)
{
if (discard_next_release)
{
-inolog("Discarded a RELEASE result\n");
+MYLOG(1, "Discarded a RELEASE result\n");
discard_next_release = FALSE;
break; /* discard the result */
}
QR_set_rstatus(res, PORES_COMMAND_OK);
QR_set_command(res, cmdbuffer);
query_completed = TRUE;
- mylog("send_query: returning res = %p\n", res);
+ MYLOG(0, "send_query: returning res = %p\n", res);
break;
case PGRES_EMPTY_QUERY:
if (stmt)
res->next->num_key_fields = stmt->num_key_fields;
}
- mylog("send_query: 'T' no result_in: res = %p\n", res->next);
+ MYLOG(0, "send_query: 'T' no result_in: res = %p\n", res->next);
res = res->next;
nrarg.res = res;
CC_set_error(self, CONNECTION_BACKEND_CRAZY, "Unexpected result status (send_query)", func);
CC_on_abort(self, CONN_DEAD);
- mylog("send_query: error - %s\n", CC_get_errormsg(self));
+ MYLOG(0, "send_query: error - %s\n", CC_get_errormsg(self));
ReadyToReturn = TRUE;
retres = NULL;
break;
PQclear(pgres);
pgres = NULL;
}
-inolog(" !!!! %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, " !!!! %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);
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);
-inolog(" !!!! %s:ignored abort_on_conn\n", __FUNCTION__);
+MYLOG(1, " !!!! %s:ignored abort_on_conn\n", __FUNCTION__);
}
else if (retres)
{
Int4 intParamBufs[MAX_SEND_FUNC_ARGS];
Int8 int8ParamBufs[MAX_SEND_FUNC_ARGS];
- mylog("send_function(): conn=%p, fn_name=%s, result_is_int=%d, nargs=%d\n", self, fn_name, result_is_int, nargs);
+ MYLOG(0, "send_function(): 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???
func_param_str[nargs]);
for (i = 0; i < nargs; ++i)
{
- mylog(" arg[%d]: len = %d, isint = %d, integer = " FORMATI64 ", ptr = %p\n", i, args[i].len, args[i].isint, args[i].isint == 2 ? args[i].u.integer64 : args[i].u.integer, args[i].u.ptr);
+ MYLOG(0, " arg[%d]: len = %d, isint = %d, integer = " FORMATI64 ", ptr = %p\n", i, args[i].len, args[i].isint, args[i].isint == 2 ? args[i].u.integer64 : args[i].u.integer, args[i].u.ptr);
/* integers are sent as binary, others as text */
if (args[i].isint == 2)
{
paramTypes, (const char * const *) paramValues,
paramLengths, paramFormats, 1);
- mylog("send_function: done sending function\n");
+ MYLOG(0, "send_function: done sending function\n");
if (PQresultStatus(pgres) != PGRES_TUPLES_OK)
{
*actual_result_len = PQgetlength(pgres, 0, 0);
- mylog("send_function(): got result with length %d\n", *actual_result_len);
+ MYLOG(0, "send_function(): got result with length %d\n", *actual_result_len);
if (*actual_result_len > 0)
{
memcpy(&int8val, value, sizeof(Int8));
int8val = odbc_ntoh64(int8val);
memcpy(result_buf, &int8val, sizeof(Int8));
-mylog("int8 result=" FORMATI64 "\n", int8val);
+MYLOG(0, "int8 result=" FORMATI64 "\n", int8val);
}
else if (result_is_int)
{
CSTR func = "CC_send_settings";
- mylog("%s: entering...\n", func);
+ MYLOG(0, "%s: entering...\n", func);
if (set_query == NULL) return TRUE;
if (!SQL_SUCCEEDED(result))
status = FALSE;
- mylog("%s: result %d, status %d from '%s'\n", func, result, status, ptr);
+ MYLOG(0, "%s: result %d, status %d from '%s'\n", func, result, status, ptr);
#ifdef HAVE_STRTOK_R
ptr = strtok_r(NULL, ";", &last);
QResultClass *res;
CSTR func = "CC_lookup_lo";
- mylog("%s: entering...\n", func);
+ MYLOG(0, "%s: entering...\n", func);
res = CC_send_query(self, "select oid, typbasetype from pg_type where typname = '" PG_TYPE_LO_NAME "'",
NULL, READ_ONLY_QUERY, NULL);
self->lobj_type = 0;
}
QR_Destructor(res);
- mylog("Got the large object oid: %d\n", self->lobj_type);
+ MYLOG(0, "Got the large object oid: %d\n", self->lobj_type);
qlog(" [ Large Object oid = %d ]\n", self->lobj_type);
return;
}
if (self)
{
qlog("CONN ERROR: func=%s, desc='%s', errnum=%d, errmsg='%s'\n", func, desc, self->__error_number, NULLCHECK(self->__error_message));
- mylog("CONN ERROR: func=%s, desc='%s', errnum=%d, errmsg='%s'\n", func, desc, self->__error_number, NULLCHECK(self->__error_message));
+ MYLOG(0, "CONN ERROR: func=%s, desc='%s', errnum=%d, errmsg='%s'\n", func, desc, self->__error_number, NULLCHECK(self->__error_message));
qlog(" ------------------------------------------------------------\n");
qlog(" henv=%p, conn=%p, status=%u, num_stmts=%d\n", self->henv, self, self->status, self->num_stmts);
qlog(" pqconn=%p, stmts=%p, lobj_type=%d\n", self->pqconn, self->stmts, self->lobj_type);
else
{
qlog("INVALID CONNECTION HANDLE ERROR: func=%s, desc='%s'\n", func, desc);
- mylog("INVALID CONNECTION HANDLE ERROR: func=%s, desc='%s'\n", func, desc);
+ MYLOG(0, "INVALID CONNECTION HANDLE ERROR: func=%s, desc='%s'\n", func, desc);
}
}
char keepalive_interval_str[20];
char *errmsg = NULL;
- mylog("connecting to the database using %s as the server and pqopt={%s}\n", self->connInfo.server, SAFE_NAME(ci->pqopt));
+ MYLOG(0, "connecting to the database using %s as the server and pqopt={%s}\n", self->connInfo.server, SAFE_NAME(ci->pqopt));
if (NULL == (conninfoOption = PQconninfoParse(SAFE_NAME(ci->pqopt), &errmsg)))
{
{
const char *errmsg;
- mylog("password retry\n");
+ MYLOG(0, "password retry\n");
errmsg = PQerrorMessage(pqconn);
CC_set_error(self, CONNECTION_SERVER_NOT_REACHED, errmsg, func);
PQfinish(pqconn);
if (CONNECTION_OK != pqret)
{
const char *errmsg;
-inolog("status=%d\n", pqret);
+MYLOG(1, "status=%d\n", pqret);
errmsg = PQerrorMessage(pqconn);
CC_set_error(self, CONNECTION_SERVER_NOT_REACHED, errmsg, func);
- mylog("Could not establish connection to the database; LIBPQ returned -> %s\n", errmsg);
+ MYLOG(0, "Could not establish connection to the database; LIBPQ returned -> %s\n", errmsg);
goto cleanup;
}
- mylog("libpq connection to the database established.\n");
+ MYLOG(0, "libpq connection to the database established.\n");
pversion = PQprotocolVersion(pqconn);
if (pversion < 3)
{
- mylog("Protocol version %d is not supported\n", pversion);
+ MYLOG(0, "Protocol version %d is not supported\n", pversion);
goto cleanup;
}
- mylog("protocol=%d\n", pversion);
+ MYLOG(0, "protocol=%d\n", pversion);
pversion = PQserverVersion(pqconn);
self->pg_version_major = pversion / 10000;
self->pg_version_minor = (pversion % 10000) / 100;
SPRINTF_FIXED(self->pg_version, "%d.%d.%d", self->pg_version_major, self->pg_version_minor, pversion % 100);
- mylog("Server version=%s\n", self->pg_version);
+ MYLOG(0, "Server version=%s\n", self->pg_version);
if (!CC_get_username(self)[0])
{
- mylog("PQuser=%s\n", PQuser(pqconn));
+ MYLOG(0, "PQuser=%s\n", PQuser(pqconn));
STRCPY_FIXED(self->connInfo.username, PQuser(pqconn));
}
self->pqconn = NULL;
}
- mylog("%s: retuning %d\n", func, ret);
+ MYLOG(0, "%s: retuning %d\n", func, ret);
return ret;
}
nameSize = sizeof(loginUser);
if (GetUserNameEx(NameUserPrincipal, loginUser, &nameSize))
{
- mylog("loginUser=%s\n", loginUser);
+ MYLOG(0, "loginUser=%s\n", loginUser);
}
else
{
switch (err)
{
case ERROR_NONE_MAPPED:
- mylog("The user name is unavailable in the specified format\n");
+ MYLOG(0, "The user name is unavailable in the specified format\n");
break;
case ERROR_NO_SUCH_DOMAIN:
- mylog("The domain controller is unavailable to perform the lookup\n");
+ MYLOG(0, "The domain controller is unavailable to perform the lookup\n");
break;
case ERROR_MORE_DATA:
- mylog("The buffer is too small\n");
+ MYLOG(0, "The buffer is too small\n");
break;
default:
- mylog("GetUserNameEx error=%d\n", err);
+ MYLOG(0, "GetUserNameEx error=%d\n", err);
break;
}
}
CC_cleanup(sconn, TRUE);
if (newconn = CC_Copy(sconn), NULL == newconn)
return newconn;
- mylog("%s:newconn=%p from %p\n", __FUNCTION__, newconn, sconn);
+ MYLOG(0, "%s:newconn=%p from %p\n", __FUNCTION__, newconn, sconn);
CC_initialize(sconn, FALSE);
if (!disposingConn)
CC_copy_conninfo(&sconn->connInfo, &newconn->connInfo);
sconn->asdum = NULL;
SYNC_AUTOCOMMIT(sconn);
CC_set_dtc_clear(sconn);
- mylog("generated connection=%p with %p\n", newconn, newconn->asdum);
+ MYLOG(0, "generated connection=%p with %p\n", newconn, newconn->asdum);
return newconn;
}
void CC_log_error(const char *func, const char *desc, const ConnectionClass *self);
int CC_send_cancel_request(const ConnectionClass *conn);
void CC_on_commit(ConnectionClass *conn);
-void CC_on_abort(ConnectionClass *conn, UDWORD opt);
+void CC_on_abort(ConnectionClass *conn, unsigned int opt);
void CC_on_abort_partial(ConnectionClass *conn);
void ProcessRollback(ConnectionClass *conn, BOOL undo, BOOL partial);
const char *CC_get_current_schema(ConnectionClass *conn);
if (SQL_C_WCHAR == fCType)
hybrid = (!is_utf8 || (same_encoding && wcs_debug));
}
- mylog("%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, "%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);
}
}
if (fCType == SQL_C_WCHAR)
unicode_count = convert_from_pgbinary(neut_str, NULL, 0) * 2;
else if (hybrid)
{
- mylog("%s:hybrid estimate\n", __FUNCTION__);
+ MYLOG(0, "%s:hybrid estimate\n", __FUNCTION__);
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("%s:hybrid convert\n", __FUNCTION__);
+ MYLOG(0, "%s:hybrid convert\n", __FUNCTION__);
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("%s:field_type=%u type=%d\n", __FUNCTION__, field_type, fCType);
+ MYLOG(0, "%s:field_type=%u type=%d\n", __FUNCTION__, field_type, fCType);
switch (field_type)
{
len = pgdc->ttlbufused;
}
- mylog("DEFAULT: len = %d, ptr = '%.*s'\n", len, len, ptr);
+ MYLOG(0, "DEFAULT: len = " FORMAT_LEN ", ptr = '%.*s'\n", len, (int) len, ptr);
if (current_col >= 0)
{
#ifdef UNICODE_SUPPORT
if (SQL_C_WCHAR == fCType)
- mylog(" SQL_C_WCHAR, default: len = %d, cbValueMax = %d, rgbValueBindRow = '%s'\n", len, cbValueMax, rgbValueBindRow);
+ MYLOG(0, " SQL_C_WCHAR, default: len = " FORMAT_LEN ", cbValueMax = " FORMAT_LEN ", rgbValueBindRow = '%s'\n", len, cbValueMax, rgbValueBindRow);
else
#endif /* UNICODE_SUPPORT */
if (SQL_C_BINARY == fCType)
- mylog(" SQL_C_BINARY, default: len = %d, cbValueMax = %d, rgbValueBindRow = '%.*s'\n", len, cbValueMax, copy_len, rgbValueBindRow);
+ MYLOG(0, " SQL_C_BINARY, default: len = " FORMAT_LEN ", cbValueMax = " FORMAT_LEN ", rgbValueBindRow = '%.*s'\n", len, cbValueMax, copy_len, rgbValueBindRow);
else
- mylog(" SQL_C_CHAR, default: len = %d, cbValueMax = %d, rgbValueBindRow = '%s'\n", len, cbValueMax, rgbValueBindRow);
+ MYLOG(0, " SQL_C_CHAR, default: len = " FORMAT_LEN ", cbValueMax = " FORMAT_LEN ", rgbValueBindRow = '%s'\n", len, cbValueMax, rgbValueBindRow);
cleanup:
*length_return = len;
memset(&std_time, 0, sizeof(SIMPLE_TIME));
- mylog("copy_and_convert: field_type = %d, fctype = %d, value = '%s', cbValueMax=%d\n", field_type, fCType, (value == NULL) ? "<NULL>" : value, cbValueMax);
+ MYLOG(0, "copy_and_convert: field_type = %d, fctype = %d, value = '%s', cbValueMax=" FORMAT_LEN "\n", field_type, fCType, (value == NULL) ? "<NULL>" : value, cbValueMax);
if (!value)
{
-mylog("null_cvt_date_string=%d\n", conn->connInfo.cvt_null_date_string);
+MYLOG(0, "null_cvt_date_string=%d\n", conn->connInfo.cvt_null_date_string);
/* a speicial handling for FOXPRO NULL -> NULL_STRING */
if (conn->connInfo.cvt_null_date_string > 0 &&
(PG_TYPE_DATE == field_type ||
*/
bZone = FALSE; /* time zone stuff is unreliable */
timestamp2stime(value, &std_time, &bZone, &zone);
-inolog("2stime fr=%d\n", std_time.fr);
+MYLOG(1, "2stime fr=%d\n", std_time.fr);
}
else
{
maxc = (int) cbValueMax / sizeof(short);
vp = value;
nval = 0;
- mylog("index=(");
+ MYLOG(0, "index=(");
for (i = 0;; i++)
{
if (sscanf(vp, "%hi", &shortv) != 1)
break;
- mylog(" %hi", shortv);
+ MYLOG(0, " %hi", shortv);
nval++;
if (nval < maxc)
short_array[i + 1] = shortv;
if (*vp == '\0')
break;
}
- mylog(") nval = %i\n", nval);
+ MYLOG(0, ") nval = %i\n", nval);
if (maxc > 0)
short_array[0] = nval;
fCType = SQL_C_CHAR;
#endif
- mylog("copy_and_convert, SQL_C_DEFAULT: fCType = %d\n", fCType);
+ MYLOG(0, "copy_and_convert, SQL_C_DEFAULT: fCType = %d\n", fCType);
}
text_bin_handling = FALSE;
for (i = 0; i < len && i < midsize - 2; i++)
midtemp[i] = toupper((UCHAR) neut_str[i]);
midtemp[i] = '\0';
- mylog("PG_TYPE_UUID: rgbValueBindRow = '%s'\n", rgbValueBindRow);
+ MYLOG(0, "PG_TYPE_UUID: rgbValueBindRow = '%s'\n", rgbValueBindRow);
break;
/*
*((UCHAR *) rgbValue + bind_row) = atoi(neut_str);
/*
- * mylog("SQL_C_BIT: bind_row = %d val = %d, cb = %d,
+ * MYLOG(0, "SQL_C_BIT: bind_row = %d val = %d, cb = %d,
* rgb=%d\n", bind_row, atoi(neut_str), cbValueMax,
* *((UCHAR *)rgbValue));
*/
{
UInt4 ival = ATOI32U(neut_str);
-inolog("SQL_C_VARBOOKMARK value=%d\n", ival);
+MYLOG(1, "SQL_C_VARBOOKMARK value=%d\n", ival);
if (pcbValue)
*pcbValueBindRow = sizeof(ival);
if (cbValueMax >= sizeof(ival))
}
else
{
- mylog("couldn't convert the type %d to SQL_C_BINARY\n", field_type);
+ MYLOG(0, "couldn't convert the type %d to SQL_C_BINARY\n", field_type);
qlog("couldn't convert the type %d to SQL_C_BINARY\n", field_type);
return COPY_UNSUPPORTED_TYPE;
}
result = char2guid(neut_str, &g);
if (COPY_OK != result)
{
- mylog("Could not convert to SQL_C_GUID");
+ MYLOG(0, "Could not convert to SQL_C_GUID");
return COPY_UNSUPPORTED_TYPE;
}
len = sizeof(g);
QueryParse query_org, *qp;
QueryBuild query_crt, *qb;
-inolog("prepareParametersNoDesc\n");
+MYLOG(1, "prepareParametersNoDesc\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("%s:parsed for the first command length=%d(%d) num_p=%d\n", func, endp2, endp1, num_p1);
+ MYLOG(0, "%s:parsed for the first command length=" FORMAT_SSIZE_T "(" FORMAT_SSIZE_T ") num_p=%d\n", func, 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("%s:parsed for the subsequent command length=%d(%d) num_p=%d\n", func, endp2, endp1, num_p1);
+ MYLOG(0, "%s:parsed for the subsequent command length=" FORMAT_SSIZE_T "(" FORMAT_SSIZE_T ") num_p=%d\n", func, endp2, endp1, num_p1);
pstmt = buildProcessedStmt(srvquery,
endp2 < 0 ? SQL_NTS : endp2,
fake_params ? 0 : num_p1);
SQLSMALLINT num_pa = 0;
ProcessedStmt *pstmt;
-inolog("prep_params_and_sync\n");
+MYLOG(1, "prep_params_and_sync\n");
retval = SQL_ERROR;
#define return DONT_CALL_RETURN_FROM_HERE???
return SQL_SUCCESS;
}
-inolog("prepareParameters\n");
+MYLOG(1, "prepareParameters\n");
if (prepareParametersNoDesc(stmt, fake_params, PARSE_PARAM_CAST) == SQL_ERROR)
return SQL_ERROR;
ConnInfo *ci = &(conn->connInfo);
const char *bestitem = NULL;
-inolog("%s: enter prepared=%d\n", func, stmt->prepared);
+MYLOG(1, "%s: enter prepared=%d\n", func, stmt->prepared);
if (!stmt->statement)
{
SC_set_error(stmt, STMT_INTERNAL_ERROR, "No statement string", func);
qp->from_pos = stmt->from_pos;
qp->where_pos = stmt->where_pos;
}
-inolog("type=%d concur=%d\n", stmt->options.cursor_type, stmt->options.scroll_concurrency);
+MYLOG(1, "type=%d concur=%d\n", stmt->options.cursor_type, stmt->options.scroll_concurrency);
}
SC_miscinfo_clear(stmt);
qb->errornumber = STMT_EXEC_ERROR;
qb->errormsg = "ODBC escape convert error";
}
- mylog("%s convert_escape error\n", func);
+ MYLOG(0, "%s convert_escape error\n", func);
return SQL_ERROR;
}
return SQL_SUCCESS;
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("%s:%s\n", __FUNCTION__, tmp);
+ MYLOG(0, "%s:%s\n", __FUNCTION__, tmp);
SC_set_error(stmt, STMT_COUNT_FIELD_INCORRECT, tmp, func);
return FALSE;
}
qb.flags |= FLGB_BINARY_AS_POSSIBLE;
- inolog("num_params=%d proc_return=%d\n", num_params, stmt->proc_return);
+ MYLOG(1, "num_params=%d proc_return=%d\n", num_params, stmt->proc_return);
num_p = num_params - qb.num_discard_params;
-inolog("num_p=%d\n", num_p);
+MYLOG(1, "num_p=%d\n", num_p);
discard_output = (0 != (qb.flags & FLGB_DISCARD_OUTPUT));
*nParams = 0;
if (num_p > 0)
goto cleanup;
}
- inolog("%dth parameter type oid is %u\n", i, PIC_dsp_pgtype(conn, parameters[i]));
+ MYLOG(1, "%dth parameter type oid is %u\n", i, PIC_dsp_pgtype(conn, parameters[i]));
if (i < qb.proc_return)
continue;
(*paramLengths)[pno] = 0;
}
if (isbinary)
- mylog("%dth parameter is of binary format\n", pno);
+ MYLOG(0, "%dth parameter is of binary format\n", pno);
(*paramFormats)[pno] = isbinary ? 1 : 0;
pno++;
UCHAR calv[MAX_NUMERIC_DIGITS];
int precision;
-inolog("C_NUMERIC [prec=%d scale=%d]", ns->precision, ns->scale);
+MYLOG(1, "C_NUMERIC [prec=%d scale=%d]", ns->precision, ns->scale);
if (0 == ns->precision)
{
* digit is at calv[0]
*/
-inolog(" len2=%d", len);
+MYLOG(1, " len2=%d", len);
/* build the final output string. */
newlen = 0;
if (0 == len)
chrform[newlen++] = '0';
chrform[newlen] = '\0';
-inolog(" convval(2) len=%d %s\n", newlen, chrform);
+MYLOG(1, " convval(2) len=%d %s\n", newlen, chrform);
}
/*
*/
param_number = ++qb->param_number;
-inolog("resolveOneParam %d(%d,%d)\n", param_number, ipdopts->allocated, apdopts->allocated);
+MYLOG(1, "resolveOneParam %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("%s:The # of (A|I)PD parameters (%d, %d) < %d the # of parameter markers\n", __FUNCTION__, apdopts->allocated, ipdopts->allocated, param_number);
+ MYLOG(0, "%s:The # of (A|I)PD parameters (%d, %d) < %d the # of parameter markers\n", __FUNCTION__, 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 */
return SQL_ERROR;
}
-inolog("ipara=%p paramType=%d %d proc_return=%d\n", ipara, ipara ? ipara->paramType : -1, PG_VERSION_LT(conn, 8.1), qb->proc_return);
+MYLOG(1, "ipara=%p paramType=%d %d proc_return=%d\n", ipara, ipara ? ipara->paramType : -1, PG_VERSION_LT(conn, 8.1), qb->proc_return);
if (param_number < qb->proc_return)
{
if (ipara && SQL_PARAM_OUTPUT != ipara->paramType)
if (0 != param_pgtype)
{
param_sqltype = pgtype_attr_to_concise_type(conn, param_pgtype, PG_ATP_UNSET, PG_ADT_UNSET, PG_UNKNOWNS_UNSET);
- mylog("%s: convert from pgtype(%u) to sqltype(%d)\n", __FUNCTION__, param_pgtype, param_sqltype);
+ MYLOG(0, "%s: convert from pgtype(%u) to sqltype(%d)\n", __FUNCTION__, param_pgtype, param_sqltype);
}
}
- mylog("%s: from(fcType)=%d, to(fSqlType)=%d(%u), *pgType=%u\n", func,
+ MYLOG(0, "%s: from(fcType)=%d, to(fSqlType)=%d(%u), *pgType=%u\n", func,
param_ctype, param_sqltype, param_pgtype, *pgType);
/* Handle NULL parameter data */
case SQL_C_CHAR:
if (!same_encoding || wcs_debug)
{
- mylog("%s:locale param convert\n", __FUNCTION__);
+ MYLOG(0, "%s:locale param convert\n", __FUNCTION__);
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("%s:hybrid param convert\n", __FUNCTION__);
+ MYLOG(0, "%s:hybrid param convert\n", __FUNCTION__);
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(" %s:C_WCHAR=%d contents=%s(%d)\n", __FUNCTION__, param_ctype, buffer, used);
+MYLOG(0, " %s:C_WCHAR=%d contents=%s(" FORMAT_LEN ")\n", __FUNCTION__, param_ctype, buffer, used);
if (NULL == send_buf)
{
allocbuf = ucs2_to_utf8((SQLWCHAR *) buffer, used > 0 ? used / WCLEN : used, &used, FALSE);
st.ss = tss->second;
st.fr = tss->fraction;
- mylog("m=%d,d=%d,y=%d,hh=%d,mm=%d,ss=%d\n", st.m, st.d, st.y, st.hh, st.mm, st.ss);
+ MYLOG(0, "m=%d,d=%d,y=%d,hh=%d,mm=%d,ss=%d\n", st.m, st.d, st.y, st.hh, st.mm, st.ss);
break;
*/
/* Special handling NULL string For FOXPRO */
-mylog("cvt_null_date_string=%d pgtype=%d send_buf=%p\n", conn->connInfo.cvt_null_date_string, param_pgtype, send_buf);
+MYLOG(0, "cvt_null_date_string=%d pgtype=%d send_buf=%p\n", conn->connInfo.cvt_null_date_string, param_pgtype, send_buf);
if (conn->connInfo.cvt_null_date_string > 0 &&
(PG_TYPE_DATE == param_pgtype ||
PG_TYPE_DATETIME == param_pgtype ||
{
if (0 != (qb->flags & FLGB_BINARY_AS_POSSIBLE))
{
- mylog("sending binary data leng=%d\n", used);
+ MYLOG(0, "sending binary data leng=" FORMAT_LEN "\n", used);
*isbinary = TRUE;
}
else
/* non-ascii characters should be
* converted to octal
*/
- mylog("SQL_VARBINARY: about to call convert_to_pgbinary, used = %d\n", used);
+ MYLOG(0, "SQL_VARBINARY: about to call convert_to_pgbinary, used = " FORMAT_LEN "\n", used);
final_binary_convert = TRUE;
}
break;
}
if (param_pos[param_count][0] >= 0)
{
- mylog("%s closing ) not found %d\n", func, innerParenthesis);
+ MYLOG(0, "%s closing ) not found %d\n", func, innerParenthesis);
qb->errornumber = STMT_EXEC_ERROR;
qb->errormsg = "processParameters closing ) not found";
return SQL_ERROR;
char num[10];
memcpy(num, nqb.query_statement + from, to - from + 1);
num[to - from + 1] = '\0';
-mylog("%d-%d num=%s SQL_BIT=%d\n", to, from, num, SQL_BIT);
+MYLOG(0, FORMAT_LEN "-" FORMAT_LEN " num=%s SQL_BIT=%d\n", to, from, num, SQL_BIT);
switch (atoi(num))
{
case SQL_BIT:
i++;
}
/** if (rgbValue)
- mylog("convert_from_pgbinary: i=%d, rgbValue[%d] = %d, %c\n", i, o, rgbValue[o], rgbValue[o]); ***/
+ MYLOG(0, "convert_from_pgbinary: i=%d, rgbValue[%d] = %d, %c\n", i, o, rgbValue[o], rgbValue[o]); ***/
}
if (rgbValue)
rgbValue[o] = '\0'; /* extra protection */
- mylog("convert_from_pgbinary: in=%d, out = %d\n", ilen, o);
+ MYLOG(0, "convert_from_pgbinary: in=" FORMAT_SIZE_T ", out = " FORMAT_SIZE_T "\n", ilen, o);
return o;
}
for (i = 0; i < len; i++)
{
inc = in[i];
- inolog("%s: in[%d] = %d, %c\n", func, i, inc, inc);
+ MYLOG(1, "%s: in[" FORMAT_SIZE_T "] = %d, %c\n", func, i, inc, inc);
if (inc < 128 && (isalnum(inc) || inc == ' '))
out[o++] = inc;
else
}
}
- mylog("%s: returning %d, out='%.*s'\n", func, o, o, out);
+ MYLOG(0, "%s: returning " FORMAT_SIZE_T ", out='%.*s'\n", func, o, (int) o, out);
return o;
}
}
else if (left64 == 0)
return COPY_NO_DATA_FOUND;
- mylog("lo data left = " FORMATI64 "\n", left64);
+ MYLOG(0, "lo data left = " FORMATI64 "\n", left64);
if (stmt->lobj_fd < 0)
{
{
int i;
-inolog("TI_Destructor count=%d\n", count);
+MYLOG(1, "TI_Destructor count=%d\n", count);
if (ti)
{
for (i = 0; i < count; i++)
COL_INFO *coli = ti[i]->col_info;
if (coli)
{
-mylog("!!!refcnt %p:%d -> %d\n", coli, coli->refcnt, coli->refcnt - 1);
+MYLOG(0, "!!!refcnt %p:%d -> %d\n", coli, coli->refcnt, coli->refcnt - 1);
coli->refcnt--;
if (coli->refcnt <= 0 && 0 == coli->acc_time) /* acc_time == 0 means the table is dropped */
free_col_info_contents(coli);
}
void FI_Constructor(FIELD_INFO *self, BOOL reuse)
{
-inolog("FI_Constructor reuse=%d\n", reuse);
+MYLOG(1, "FI_Constructor reuse=%d\n", reuse);
if (reuse)
FI_Destructor(&self, 1, FALSE);
memset(self, 0, sizeof(FIELD_INFO));
{
int i;
-inolog("FI_Destructor count=%d\n", count);
+MYLOG(1, "FI_Destructor count=%d\n", count);
if (fi)
{
for (i = 0; i < count; i++)
static void ARDFields_free(ARDFields * self)
{
-inolog("ARDFields_free %p bookmark=%p", self, self->bookmark);
+MYLOG(1, "ARDFields_free %p bookmark=%p", self, self->bookmark);
if (self->bookmark)
{
free(self->bookmark);
self->bookmark = NULL;
}
-inolog(" hey");
+MYLOG(1, " hey");
/*
* the memory pointed to by the bindings is not deallocated by the
* driver but by the application that uses that driver, so we don't
int new_num_descs;
DescriptorClass **descs;
- mylog("CC_add_descriptor: self=%p, desc=%p\n", self, desc);
+ MYLOG(0, "CC_add_descriptor: self=%p, desc=%p\n", self, desc);
for (i = 0; i < self->num_descs; i++)
{
RETCODE ret = SQL_SUCCESS;
DescriptorClass *desc;
- mylog("%s: entering...\n", func);
+ MYLOG(0, "%s: entering...\n", func);
desc = (DescriptorClass *) malloc(sizeof(DescriptorClass));
if (desc)
DescriptorClass *desc = (DescriptorClass *) DescriptorHandle;
RETCODE ret = SQL_SUCCESS;
- mylog("%s: entering...\n", func);
+ MYLOG(0, "%s: entering...\n", func);
DC_Destructor(desc);
if (!desc->deschd.embedded)
{
APDFields *apd_src, *apd_tgt;
IPDFields *ipd_src, *ipd_tgt;
- mylog("%s: entering...\n", func);
+ MYLOG(0, "%s: entering...\n", func);
src = (DescriptorClass *) SourceDescHandle;
target = (DescriptorClass *) TargetDescHandle;
srchd = &(src->deschd);
targethd = &(target->deschd);
if (!srchd->type_defined)
{
- mylog("source type undefined\n");
+ MYLOG(0, "source type undefined\n");
DC_set_error(target, DESC_EXEC_ERROR, "source handle type undefined");
return ret;
}
if (targethd->type_defined)
{
-inolog("source type=%d -> target type=%d\n", srchd->desc_type, targethd->desc_type);
+MYLOG(1, "source type=%d -> target type=%d\n", srchd->desc_type, targethd->desc_type);
if (SQL_ATTR_IMP_ROW_DESC == targethd->desc_type)
{
- mylog("can't modify IRD\n");
+ MYLOG(0, "can't modify IRD\n");
DC_set_error(target, DESC_EXEC_ERROR, "can't copy to IRD");
return ret;
}
{
if (targethd->embedded)
{
- mylog("src type != target type\n");
+ MYLOG(0, "src type != target type\n");
DC_set_error(target, DESC_EXEC_ERROR, "copying different type descriptor to embedded one");
return ret;
}
switch (srchd->desc_type)
{
case SQL_ATTR_APP_ROW_DESC:
-inolog("src=%p target=%p type=%d", src, target, srchd->desc_type);
+MYLOG(1, "src=%p target=%p type=%d", src, target, srchd->desc_type);
if (!targethd->type_defined)
{
targethd->desc_type = srchd->desc_type;
}
ard_src = &(src->ardf);
-inolog(" rowset_size=%d bind_size=%d ope_ptr=%p off_ptr=%p\n",
+MYLOG(1, " rowset_size=" FORMAT_LEN " bind_size=%d ope_ptr=%p off_ptr=%p\n",
ard_src->size_of_rowset, ard_src->bind_size,
ard_src->row_operation_ptr, ard_src->row_offset_ptr);
ard_tgt = &(target->ardf);
-inolog(" target=%p", ard_tgt);
+MYLOG(1, " target=%p", ard_tgt);
ARDFields_copy(ard_src, ard_tgt);
-inolog(" offset_ptr=%p\n", ard_tgt->row_offset_ptr);
+MYLOG(1, " offset_ptr=%p\n", ard_tgt->row_offset_ptr);
break;
case SQL_ATTR_APP_PARAM_DESC:
if (!targethd->type_defined)
IPDFields_copy(ipd_src, ipd_tgt);
break;
default:
- mylog("invalid descriptor handle type=%d\n", srchd->desc_type);
+ MYLOG(0, "invalid descriptor handle type=%d\n", srchd->desc_type);
DC_set_error(target, DESC_EXEC_ERROR, "invalid descriptor type");
ret = SQL_ERROR;
}
if (self)
{
qlog("DESCRIPTOR ERROR: func=%s, desc='%s', errnum=%d, errmsg='%s'\n", func, desc, self->deschd.__error_number, nullcheck(self->deschd.__error_message));
- mylog("DESCRIPTOR ERROR: func=%s, desc='%s', errnum=%d, errmsg='%s'\n", func, desc, self->deschd.__error_number, nullcheck(self->deschd.__error_message));
+ MYLOG(0, "DESCRIPTOR ERROR: func=%s, desc='%s', errnum=%d, errmsg='%s'\n", func, desc, self->deschd.__error_number, nullcheck(self->deschd.__error_message));
}
}
DescriptorClass *desc = (DescriptorClass *) hdesc;
DescriptorHeader *deschd = &(desc->deschd);
- mylog("%s RecN=%d\n", func);
+ MYLOG(0, "%s RecN=%hd\n", func, RecNumber);
deschd->pgerror = DC_create_errorinfo(desc);
return ER_ReturnError(deschd->pgerror, RecNumber, szSqlState,
pfNativeError, szErrorMsg, cbErrorMsgMax,
BOOL abbrev = (len < 1024) || 0 < ci->force_abbrev_connstr;
UInt4 flag;
-inolog("force_abbrev=%d abbrev=%d\n", ci->force_abbrev_connstr, abbrev);
+MYLOG(1, "force_abbrev=%d abbrev=%d\n", ci->force_abbrev_connstr, abbrev);
encode(ci->password, encoded_item, sizeof(encoded_item));
/* fundamental info */
nlen = MAX_CONNECT_STRING;
/* extra info */
hlen = strlen(connect_string);
nlen = MAX_CONNECT_STRING - hlen;
-inolog("hlen=%d", hlen);
+MYLOG(1, "hlen=" FORMAT_SSIZE_T, hlen);
if (!abbrev)
{
char protocol_and[16];
{
ci->password = decode_or_remove_braces(value);
#ifndef FORCE_PASSWORDE_DISPLAY
- mylog("%s: key='%s' value='xxxxxxxx'\n", __FUNCTION__, attribute);
+ MYLOG(0, "%s: key='%s' value='xxxxxxxx'\n", __FUNCTION__, attribute);
printed = TRUE;
#endif
}
/* ignore first part */
}
ci->rollback_on_error = atoi(ptr + 1);
- mylog("%s:key='%s' value='%s' rollback_on_error=%d\n",
+ MYLOG(0, "%s:key='%s' value='%s' rollback_on_error=%d\n",
__FUNCTION__, attribute, value, ci->rollback_on_error);
printed = TRUE;
}
STRCPY_FIXED(ci->sslmode, SSLMODE_DISABLE);
break;
}
- mylog("%s:key='%s' value='%s' set to '%s'\n",
+ MYLOG(0, "%s:key='%s' value='%s' set to '%s'\n",
__FUNCTION__, attribute, value, ci->sslmode);
printed = TRUE;
}
{
setExtraOptions(ci, value, hex_format);
}
- mylog("%s:key='%s' value='%s'(force_abbrev=%d bde=%d cvt_null_date=%x)\n",
+ 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);
printed = TRUE;
}
found = FALSE;
if (!printed)
- mylog("%s: key='%s' value='%s'%s\n", __FUNCTION__, attribute,
+ MYLOG(0, "%s: key='%s' value='%s'%s\n", __FUNCTION__, attribute,
value, found ? NULL_STRING : " not found");
return found;
static void
getCiDefaults(ConnInfo *ci)
{
- mylog("calling %s\n", __FUNCTION__);
+ MYLOG(0, "calling %s\n", __FUNCTION__);
ci->drivers.debug = DEFAULT_DEBUG;
ci->drivers.commlog = DEFAULT_COMMLOG;
void getDriversDefaults(const char *drivername, GLOBAL_VALUES *comval)
{
- mylog("%s:%p of the driver %s\n", __FUNCTION__, comval, NULL_IF_NULL(drivername));
+ MYLOG(0, "%s:%p of the driver %s\n", __FUNCTION__, comval, NULL_IF_NULL(drivername));
get_Ci_Drivers(drivername, ODBCINST_INI, comval);
if (NULL != drivername)
STR_TO_NAME(comval->drivername, 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("%s: DSN=%s driver=%s&%s\n", func, DSN,
+ MYLOG(0, "%s: DSN=%s driver=%s&%s\n", func, DSN,
ci->drivername, NULL_IF_NULL(configDrvrname));
getCiDefaults(ci);
if (!drivername[0] && DSN[0])
getDriverNameFromDSN(DSN, (char *) drivername, sizeof(ci->drivername));
-mylog("drivername=%s\n", drivername);
+MYLOG(0, "drivername=%s\n", drivername);
if (!drivername[0])
drivername = INVALID_DRIVER;
getDriversDefaults(drivername, &(ci->drivers));
{
*ptr = '\0';
ci->rollback_on_error = atoi(ptr + 1);
- mylog("rollback_on_error=%d\n", ci->rollback_on_error);
+ MYLOG(0, "rollback_on_error=%d\n", ci->rollback_on_error);
}
}
sscanf(temp, "%x", &val);
replaceExtraOptions(ci, val, TRUE);
- mylog("force_abbrev=%d bde=%d cvt_null_date=%d\n", ci->force_abbrev_connstr, ci->bde_environment, ci->cvt_null_date_string);
+ MYLOG(0, "force_abbrev=%d bde=%d cvt_null_date=%d\n", ci->force_abbrev_connstr, ci->bde_environment, ci->cvt_null_date_string);
}
/* Allow override of odbcinst.ini parameters here */
BOOL inst_position = (stricmp(filename, ODBCINST_INI) == 0);
if (0 != strcmp(ODBCINST_INI, filename))
- mylog("%s:setting %s position of %s(%p)\n", func, filename, section, comval);
+ MYLOG(0, "%s:setting %s position of %s(%p)\n", func, filename, section, comval);
/*
* It's not appropriate to handle debug or commlog here.
if (strcmp(temp, ENTRY_TEST))
STRCPY_FIXED(comval->extra_systable_prefixes, temp);
- mylog("comval=%p comval->extra_systable_prefixes = '%s'\n", comval, comval->extra_systable_prefixes);
+ MYLOG(0, "comval=%p comval->extra_systable_prefixes = '%s'\n", comval, comval->extra_systable_prefixes);
/* Dont allow override of an override! */
return NULL;
memcpy(rptr, sptr, len);
rptr[len] = '\0';
- mylog("extracted a %s '%s' from %s\n", attr, rptr, str);
+ MYLOG(0, "extracted a %s '%s' from %s\n", attr, rptr, str);
return rptr;
}
CC_conninfo_init(ConnInfo *conninfo, UInt4 option)
{
CSTR func = "CC_conninfo_init";
- mylog("%s opt=%d\n", func, option);
+ MYLOG(0, "%s opt=%d\n", func, option);
if (0 != (CLEANUP_FOR_REUSE & option))
CC_conninfo_release(conninfo);
CORR_STRCPY(extra_systable_prefixes);
CORR_STRCPY(protocol);
- mylog("copy_globals driver=%s\n", SAFE_NAME(to->drivername));
+ MYLOG(0, "copy_globals driver=%s\n", SAFE_NAME(to->drivername));
}
void finalize_globals(GLOBAL_VALUES *glbv)
const char * drivername = NULL;
GLOBAL_VALUES defval;
-mylog("!!!! %s;%d in\n", __FUNCTION__, src);
+MYLOG(0, "!!!! %s;%d in\n", __FUNCTION__, src);
init_globals(&defval);
switch (src)
{
{
GLOBAL_VALUES *comval;
-// mylog("!!!! %s in\n", __FUNCTION__);
+// MYLOG(0, "!!!! %s in\n", __FUNCTION__);
comval = &(ci->drivers);
comval->commlog = IsDlgButtonChecked(hdlg, DRV_COMMLOG);
*proc = NULL;
if (hmodule = LoadLibraryEx(GetXaLibPath(), NULL, LOAD_WITH_ALTERED_SEARCH_PATH), NULL != hmodule)
{
-mylog("GetProcAddres for %s\n", procname);
+MYLOG(0, "GetProcAddres for %s\n", procname);
*proc = GetProcAddress(hmodule, procname);
}
GLOBAL_VALUES defval;
// if (WM_INITDIALOG == wMsg || WM_COMMAND == wMsg)
-// mylog("!!!! %s:%d in\n", __FUNCTION__, wMsg);
+// MYLOG(0, "!!!! %s:%d in\n", __FUNCTION__, wMsg);
init_globals(&defval);
switch (wMsg)
{
char strbuf[128];
// if (WM_INITDIALOG == wMsg || WM_COMMAND == wMsg)
-// mylog("!!!! %s:%d in\n", __FUNCTION__, wMsg);
+// MYLOG(0, "!!!! %s:%d in\n", __FUNCTION__, wMsg);
switch (wMsg)
{
case WM_INITDIALOG:
{
char buf[128];
- mylog("%s: got ci = %p\n", __FUNCTION__, ci);
+ MYLOG(0, "%s: got ci = %p\n", __FUNCTION__, ci);
/* Readonly */
ITOA_FIXED(ci->onlyread, IsDlgButtonChecked(hdlg, DS_READONLY));
BOOL enable;
// if (WM_INITDIALOG == wMsg || WM_COMMAND == wMsg)
-// mylog("!!!! %s:%d in\n", __FUNCTION__, wMsg);
+// MYLOG(0, "!!!! %s:%d in\n", __FUNCTION__, wMsg);
switch (wMsg)
{
case WM_INITDIALOG:
switch (cmd = GET_WM_COMMAND_ID(wParam, lParam))
{
case DS_SHOWOIDCOLUMN:
- mylog("WM_COMMAND: DS_SHOWOIDCOLUMN\n");
+ MYLOG(0, "WM_COMMAND: DS_SHOWOIDCOLUMN\n");
EnableWindow(GetDlgItem(hdlg, DS_FAKEOIDINDEX), IsDlgButtonChecked(hdlg, DS_SHOWOIDCOLUMN));
return TRUE;
case DS_DISABLE_KEEPALIVE:
- mylog("WM_COMMAND: DS_SHOWOIDCOLUMN\n");
+ MYLOG(0, "WM_COMMAND: DS_SHOWOIDCOLUMN\n");
EnableWindow(GetDlgItem(hdlg, DS_KEEPALIVETIME), !IsDlgButtonChecked(hdlg, cmd));
EnableWindow(GetDlgItem(hdlg, DS_KEEPALIVEINTERVAL), !IsDlgButtonChecked(hdlg, cmd));
return TRUE;
BOOL enable = TRUE;
static BOOL defset = FALSE;
-mylog("!!!! %s in\n", __FUNCTION__);
+MYLOG(0, "!!!! %s in\n", __FUNCTION__);
#ifdef _HANDLE_ENLIST_IN_DTC_
switch (ci->xa_opt)
{
PQCONNINFOPARSEPROC pproc = NULL;
PQCONNINFOFREEPROC fproc = NULL;
- mylog("%s: got ci = %p\n", __FUNCTION__, ci);
+ MYLOG(0, "%s: got ci = %p\n", __FUNCTION__, ci);
/* Datasource libpq parameters */
GetDlgItemText(hdlg, DS_LIBPQOPT, pqopt, sizeof(pqopt));
DWORD cmd;
if (WM_INITDIALOG == wMsg || WM_COMMAND == wMsg)
-mylog("!!!! %s:%d in\n", __FUNCTION__, wMsg);
+MYLOG(0, "!!!! %s:%d in\n", __FUNCTION__, wMsg);
switch (wMsg)
{
case WM_INITDIALOG:
int reqs = 0;
- mylog("%s: entering...\n", func);
+ MYLOG(0, "%s: entering...\n", func);
if (!conn)
{
connStrIn = make_string(szConnStrIn, cbConnStrIn, NULL, 0);
#ifdef FORCE_PASSWORD_DISPLAY
- mylog("**** PGAPI_DriverConnect: fDriverCompletion=%d, connStrIn='%s'\n", fDriverCompletion, connStrIn);
+ MYLOG(0, "**** PGAPI_DriverConnect: fDriverCompletion=%d, connStrIn='%s'\n", fDriverCompletion, connStrIn);
qlog("conn=%p, PGAPI_DriverConnect( in)='%s', fDriverCompletion=%d\n", conn, connStrIn, fDriverCompletion);
#else
if (get_qlog() || get_mylog())
{
char *hide_str = hide_password(connStrIn);
- mylog("**** PGAPI_DriverConnect: fDriverCompletion=%d, connStrIn='%s'\n", fDriverCompletion, NULL_IF_NULL(hide_str));
+ MYLOG(0, "**** PGAPI_DriverConnect: fDriverCompletion=%d, connStrIn='%s'\n", fDriverCompletion, NULL_IF_NULL(hide_str));
qlog("conn=%p, PGAPI_DriverConnect( in)='%s', fDriverCompletion=%d\n", conn, NULL_IF_NULL(hide_str), fDriverCompletion);
if (hide_str)
free(hide_str);
#ifdef WIN32
dialog:
#endif
-inolog("DriverCompletion=%d\n", fDriverCompletion);
+MYLOG(1, "DriverCompletion=%d\n", fDriverCompletion);
switch (fDriverCompletion)
{
#ifdef WIN32
}
reqs = 0;
-inolog("before CC_connect\n");
+MYLOG(1, "before CC_connect\n");
/* do the actual connect */
retval = CC_connect(conn, salt);
if (retval < 0)
#ifdef FORCE_PASSWORD_DISPLAY
if (cbConnStrOutMax > 0)
{
- mylog("szConnStrOut = '%s' len=%d,%d\n", NULL_IF_NULL((char *) szConnStrOut), len, cbConnStrOutMax);
+ MYLOG(0, "szConnStrOut = '%s' len=" FORMAT_SSIZE_T ",%d\n", NULL_IF_NULL((char *) szConnStrOut), len, cbConnStrOutMax);
qlog("conn=%p, PGAPI_DriverConnect(out)='%s'\n", conn, NULL_IF_NULL((char *) szConnStrOut));
}
#else
if (cbConnStrOutMax > 0)
hide_str = hide_password(szConnStrOut);
- mylog("szConnStrOut = '%s' len=%d,%d\n", NULL_IF_NULL(hide_str), len, cbConnStrOutMax);
+ MYLOG(0, "szConnStrOut = '%s' len=%d,%d\n", NULL_IF_NULL(hide_str), len, cbConnStrOutMax);
qlog("conn=%p, PGAPI_DriverConnect(out)='%s'\n", conn, NULL_IF_NULL(hide_str));
if (hide_str)
free(hide_str);
}
#endif /* FORCE_PASSWORD_DISPLAY */
- mylog("PGAPI_DriverConnect: returning %d\n", result);
+ MYLOG(0, "PGAPI_DriverConnect: returning %d\n", result);
return result;
}
{
LRESULT dialog_result;
- mylog("dconn_DoDialog: ci = %p\n", ci);
+ MYLOG(0, "dconn_DoDialog: ci = %p\n", ci);
if (hwnd)
{
if (-1 == dialog_result)
{
int errc = GetLastError();
- mylog(" %s:LastError=%d\n", __FUNCTION__, errc);
+ MYLOG(0, " %s:LastError=%d\n", __FUNCTION__, errc);
}
if (!dialog_result || (dialog_result == -1))
return SQL_NO_DATA_FOUND;
return SQL_SUCCESS;
}
- mylog(" %s:No window specified\n", __FUNCTION__);
+ MYLOG(0, " %s:No window specified\n", __FUNCTION__);
return SQL_ERROR;
}
strtok_arg = our_connect_string;
#ifdef FORCE_PASSWORD_DISPLAY
- mylog("our_connect_string = '%s'\n", our_connect_string);
+ MYLOG(0, "our_connect_string = '%s'\n", our_connect_string);
#else
if (get_mylog())
{
char *hide_str = hide_password(our_connect_string);
- mylog("our_connect_string = '%s'\n", hide_str);
+ MYLOG(0, "our_connect_string = '%s'\n", hide_str);
free(hide_str);
}
#endif /* FORCE_PASSWORD_DISPLAY */
{
if (!delp) /* error */
{
- mylog("%s closing bracket doesn't exist 1\n", __FUNCTION__);
+ MYLOG(0, "%s closing bracket doesn't exist 1\n", __FUNCTION__);
ret = FALSE;
goto cleanup;
}
closep = strchr(delp + 1, CLOSING_BRACKET);
if (!closep) /* error */
{
- mylog("%s closing bracket doesn't exist 2\n", __FUNCTION__);
+ MYLOG(0, "%s closing bracket doesn't exist 2\n", __FUNCTION__);
ret = FALSE;
goto cleanup;
}
eoftok = TRUE;
break;
}
-mylog("%s subsequent char to the closing bracket is %c value=%s\n", __FUNCTION__, closep[1], value);
+MYLOG(0, "%s subsequent char to the closing bracket is %c value=%s\n", __FUNCTION__, closep[1], value);
ret = FALSE;
goto cleanup;
}
CSTR func = "PGAPI_AllocEnv";
SQLRETURN ret = SQL_SUCCESS;
- mylog("**** in %s ** \n", func);
+ MYLOG(0, "**** in %s ** \n", func);
/*
* For systems on which none of the constructor-making
ret = SQL_ERROR;
}
- mylog("** exit %s: phenv = %p **\n", func, *phenv);
+ MYLOG(0, "** exit %s: phenv = %p **\n", func, *phenv);
return ret;
}
SQLRETURN ret = SQL_SUCCESS;
EnvironmentClass *env = (EnvironmentClass *) henv;
- mylog("**** in PGAPI_FreeEnv: env = %p ** \n", env);
+ MYLOG(0, "**** in PGAPI_FreeEnv: env = %p ** \n", env);
if (env && EN_Destructor(env))
{
- mylog(" ok\n");
+ MYLOG(0, " ok\n");
goto cleanup;
}
- mylog(" error\n");
+ MYLOG(0, " error\n");
ret = SQL_ERROR;
EN_log_error(func, "Error freeing environment", NULL);
cleanup:
return SQL_NO_DATA_FOUND;
error = pgerror;
msg = error->__error_message;
- mylog("%s: status = %d, msg = #%s#\n", func, error->status, msg);
+ MYLOG(0, "%s: status = %d, msg = #%s#\n", func, error->status, msg);
msglen = (SQLSMALLINT) strlen(msg);
/*
* Even though an application specifies a larger error message
if (NULL != szSqlState)
strncpy_null((char *) szSqlState, error->sqlstate, 6);
- mylog(" szSqlState = '%s',len=%d, szError='%s'\n", szSqlState, pcblen, szErrorMsg);
+ MYLOG(0, " szSqlState = '%s',len=%d, szError='%s'\n", szSqlState, pcblen, szErrorMsg);
if (wrtlen == 0)
return SQL_SUCCESS_WITH_INFO;
else
BOOL once_again = FALSE;
ssize_t msglen;
- mylog("**** PGAPI_ConnectError: hdbc=%p <%d>\n", hdbc, cbErrorMsgMax);
+ MYLOG(0, "**** PGAPI_ConnectError: hdbc=%p <%d>\n", hdbc, cbErrorMsgMax);
if (RecNumber != 1 && RecNumber != -1)
return SQL_NO_DATA_FOUND;
if (cbErrorMsgMax < 0)
return SQL_ERROR;
if (CONN_EXECUTING == conn->status || !CC_get_error(conn, &status, &msg) || NULL == msg)
{
- mylog("CC_Get_error returned nothing.\n");
+ MYLOG(0, "CC_Get_error returned nothing.\n");
if (NULL != szSqlState)
strncpy_null((char *) szSqlState, "00000", SIZEOF_SQLSTATE);
if (NULL != pcbErrorMsg)
return SQL_NO_DATA_FOUND;
}
- mylog("CC_get_error: status = %d, msg = #%s#\n", status, msg);
+ MYLOG(0, "CC_get_error: status = %d, msg = #%s#\n", status, msg);
msglen = strlen(msg);
if (NULL != pcbErrorMsg)
}
}
- mylog(" szSqlState = '%s',len=%d, szError='%s'\n", szSqlState ? (char *) szSqlState : PRINT_NULL, msglen, szErrorMsg ? (char *) szErrorMsg : PRINT_NULL);
+ MYLOG(0, " szSqlState = '%s',len=" FORMAT_SSIZE_T ", szError='%s'\n", szSqlState ? (char *) szSqlState : PRINT_NULL, msglen, szErrorMsg ? (char *) szErrorMsg : PRINT_NULL);
if (once_again)
{
CC_set_errornumber(conn, status);
char *msg = NULL;
int status;
- mylog("**** PGAPI_EnvError: henv=%p <%d>\n", henv, cbErrorMsgMax);
+ MYLOG(0, "**** PGAPI_EnvError: henv=%p <%d>\n", henv, cbErrorMsgMax);
if (RecNumber != 1 && RecNumber != -1)
return SQL_NO_DATA_FOUND;
if (cbErrorMsgMax < 0)
return SQL_ERROR;
if (!EN_get_error(env, &status, &msg) || NULL == msg)
{
- mylog("EN_get_error: msg = #%s#\n", msg);
+ MYLOG(0, "EN_get_error: msg = #%s#\n", msg);
if (NULL != szSqlState)
pg_sqlstate_set(env, szSqlState, "00000", "00000");
return SQL_NO_DATA_FOUND;
}
- mylog("EN_get_error: status = %d, msg = #%s#\n", status, msg);
+ MYLOG(0, "EN_get_error: status = %d, msg = #%s#\n", status, msg);
if (NULL != pcbErrorMsg)
*pcbErrorMsg = (SQLSMALLINT) strlen(msg);
if (WSAStartup(wVersionRequested, &wsaData))
{
- mylog("%s: WSAStartup error\n", __FUNCTION__);
+ MYLOG(0, "%s: WSAStartup error\n", __FUNCTION__);
return rv;
}
/* Verify that this is the minimum version of WinSock */
;
else
{
- mylog("%s: WSAStartup version=(%d,%d)\n", __FUNCTION__,
+ MYLOG(0, "%s: WSAStartup version=(%d,%d)\n", __FUNCTION__,
LOBYTE(wsaData.wVersion), HIBYTE(wsaData.wVersion));
goto cleanup;
}
rv = (EnvironmentClass *) malloc(sizeof(EnvironmentClass));
if (NULL == rv)
{
- mylog("%s: malloc error\n", __FUNCTION__);
+ MYLOG(0, "%s: malloc error\n", __FUNCTION__);
goto cleanup;
}
rv->errormsg = 0;
int lf, nullcnt;
char rv = 1;
- mylog("in EN_Destructor, self=%p\n", self);
+ MYLOG(0, "in EN_Destructor, self=%p\n", self);
if (!self)
return 0;
}
if (conns && nullcnt >= conns_count)
{
- mylog("clearing conns count=%d\n", conns_count);
+ MYLOG(0, "clearing conns count=%d\n", conns_count);
free(conns);
conns = NULL;
conns_count = 0;
#ifdef WIN32
WSACleanup();
#endif
- mylog("exit EN_Destructor: rv = %d\n", rv);
+ MYLOG(0, "exit EN_Destructor: rv = %d\n", rv);
#ifdef _MEMORY_DEBUG_
debug_memory_check();
#endif /* _MEMORY_DEBUG_ */
ConnectionClass **newa;
char ret = FALSE;
- mylog("EN_add_connection: self = %p, conn = %p\n", self, conn);
+ MYLOG(0, "EN_add_connection: self = %p, conn = %p\n", self, conn);
ENTER_CONNS_CS;
for (i = 0; i < conns_count; i++)
conn->henv = self;
conns[i] = conn;
ret = TRUE;
- mylog(" added at i=%d, conn->henv = %p, conns[i]->henv = %p\n", i, conn->henv, conns[i]->henv);
+ MYLOG(0, " added at i=%d, conn->henv = %p, conns[i]->henv = %p\n", i, conn->henv, conns[i]->henv);
goto cleanup;
}
}
newa[conns_count] = conn;
conns = newa;
ret = TRUE;
- mylog(" added at %d, conn->henv = %p, conns[%d]->henv = %p\n", conns_count, conn->henv, conns_count, conns[conns_count]->henv);
+ MYLOG(0, " added at %d, conn->henv = %p, conns[%d]->henv = %p\n", conns_count, conn->henv, conns_count, conns[conns_count]->henv);
for (i = conns_count + 1; i < alloc; i++)
conns[i] = NULL;
conns_count = alloc;
RETCODE retval = SQL_SUCCESS;
BOOL prepared;
- mylog("%s: entering...\n", func);
+ MYLOG(0, "%s: entering...\n", func);
#define return DONT_CALL_RETURN_FROM_HERE???
/* StartRollbackState(self); */
switch (self->status)
{
case STMT_DESCRIBED:
- mylog("**** PGAPI_Prepare: STMT_DESCRIBED, recycle\n");
+ MYLOG(0, "**** PGAPI_Prepare: STMT_DESCRIBED, recycle\n");
SC_recycle_statement(self); /* recycle the statement, but do
* not remove parameter bindings */
break;
case STMT_FINISHED:
- mylog("**** PGAPI_Prepare: STMT_FINISHED, recycle\n");
+ MYLOG(0, "**** PGAPI_Prepare: STMT_FINISHED, recycle\n");
SC_recycle_statement(self); /* recycle the statement, but do
* not remove parameter bindings */
break;
case STMT_ALLOCATED:
- mylog("**** PGAPI_Prepare: STMT_ALLOCATED, copy\n");
+ MYLOG(0, "**** PGAPI_Prepare: STMT_ALLOCATED, copy\n");
self->status = STMT_READY;
break;
case STMT_READY:
- mylog("**** PGAPI_Prepare: STMT_READY, change SQL\n");
+ MYLOG(0, "**** PGAPI_Prepare: STMT_READY, change SQL\n");
if (NOT_YET_PREPARED != prepared)
SC_recycle_statement(self); /* recycle the statement */
break;
case STMT_EXECUTING:
- mylog("**** PGAPI_Prepare: STMT_EXECUTING, error!\n");
+ MYLOG(0, "**** PGAPI_Prepare: 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
-inolog("SQLPrepare return=%d\n", retval);
+MYLOG(1, "SQLPrepare return=%d\n", retval);
return retval;
}
CSTR func = "PGAPI_ExecDirect";
const ConnectionClass *conn = SC_get_conn(stmt);
- mylog("%s: entering...%x\n", func, flag);
+ MYLOG(0, "%s: entering...%x\n", func, flag);
if (result = SC_initialize_and_recycle(stmt), SQL_SUCCESS != result)
return result;
* execute this statement again
*/
stmt->statement = make_string(szSqlStr, cbSqlStr, NULL, 0);
-inolog("a2\n");
+MYLOG(1, "a2\n");
if (!stmt->statement)
{
SC_set_error(stmt, STMT_NO_MEMORY_ERROR, "No memory available to store statement", func);
return SQL_ERROR;
}
- mylog("**** %s: hstmt=%p, statement='%s'\n", func, hstmt, stmt->statement);
+ MYLOG(0, "**** %s: hstmt=%p, statement='%s'\n", func, hstmt, stmt->statement);
if (0 != (flag & PODBC_WITH_HOLD))
SC_set_with_hold(stmt);
return SQL_ERROR;
}
- mylog("%s: calling PGAPI_Execute...\n", func);
+ MYLOG(0, "%s: calling PGAPI_Execute...\n", func);
result = PGAPI_Execute(hstmt, flag);
- mylog("%s: returned %hd from PGAPI_Execute\n", func, result);
+ MYLOG(0, "%s: returned %hd from PGAPI_Execute\n", func, result);
return result;
}
*exec_end = FALSE;
conn = SC_get_conn(stmt);
- mylog("%s: copying statement params: trans_status=%d, len=%d, stmt='%s'\n", func, conn->transact_status, strlen(stmt->statement), stmt->statement);
+ 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);
#define return DONT_CALL_RETURN_FROM_HERE???
#define RETURN(code) { retval = code; goto cleanup; }
if (HowToPrepareBeforeExec(stmt, FALSE) >= allowParse)
prepare_before_exec = TRUE;
-inolog("prepare_before_exec=%d srv=%d\n", prepare_before_exec, conn->connInfo.use_server_side_prepare);
+MYLOG(1, "prepare_before_exec=%d srv=%d\n", prepare_before_exec, conn->connInfo.use_server_side_prepare);
/* Create the statement with parameters substituted. */
retval = copy_statement_with_parameters(stmt, prepare_before_exec);
stmt->current_exec_param = -1;
RETURN(retval) /* error msg is passed from the above */
}
- mylog(" stmt_with_params = '%s'\n", stmt->stmt_with_params);
+ MYLOG(0, " stmt_with_params = '%s'\n", stmt->stmt_with_params);
/*
* The real execution.
*/
-mylog("about to begin SC_execute\n");
+MYLOG(0, "about to begin SC_execute\n");
retval = SC_execute(stmt);
if (retval == SQL_ERROR)
{
ConnectionClass *conn;
ConnInfo *ci = NULL;
-inolog("%s:%p->external=%d\n", func, stmt, stmt->external);
+MYLOG(1, "%s:%p->external=%d\n", func, stmt, stmt->external);
conn = SC_get_conn(stmt);
if (conn)
ci = &conn->connInfo;
ENTER_CONN_CS(conn);
conn->lock_CC_for_rb++;
}
-inolog(" !!!! %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, " !!!! %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);
conn->opt_in_progress &= option;
switch (stmt->statement_type)
{
}
}
CC_set_accessed_db(conn);
-inolog("%s:%p->accessed=%d\n", func, conn, CC_accessed_db(conn));
+MYLOG(1, "%s:%p->accessed=%d\n", func, conn, CC_accessed_db(conn));
return ret;
}
ConnectionClass *conn = SC_get_conn(stmt);
BOOL start_stmt = FALSE;
-inolog("%s:%p->accessed=%d is_in=%d is_rb=%d is_tc=%d\n", func, conn, CC_accessed_db(conn),
+MYLOG(1, "%s:%p->accessed=%d is_in=%d is_rb=%d is_tc=%d\n", func, 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("%s:in_progress=%u previous=%d\n", func, conn->opt_in_progress, conn->opt_previous);
+ MYLOG(0, "%s:in_progress=%u previous=%d\n", func, conn->opt_in_progress, conn->opt_previous);
switch (ret)
{
case SQL_NEED_DATA:
}
else if (errorOnly)
return ret;
-inolog("ret=%d\n", ret);
+MYLOG(1, "ret=%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--;
- inolog(" %s:release conn_lock\n", __FUNCTION__);
+ MYLOG(1, " %s:release conn_lock\n", __FUNCTION__);
}
CC_start_stmt(conn);
}
BOOL exec_end, recycled = FALSE, recycle = TRUE;
SQLSMALLINT num_params;
- mylog("%s: entering...%x\n", func, flag);
+ MYLOG(0, "%s: entering...%x\n", func, flag);
conn = SC_get_conn(stmt);
apdopts = SC_get_APDF(stmt);
SC_recycle_statement(stmt);
}
- mylog("%s: clear errors...\n", func);
+ MYLOG(0, "%s: clear errors...\n", func);
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("%s: problem with handle\n", func);
+ MYLOG(0, "%s: problem with handle\n", func);
return SQL_ERROR;
}
*/
else if (stmt->status == STMT_FINISHED)
{
- mylog("%s: recycling statement (should have been done by app)...\n", func);
+ MYLOG(0, "%s: recycling statement (should have been done by app)...\n", func);
/******** 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("%s: problem with statement\n", func);
+ MYLOG(0, "%s: problem with statement\n", func);
retval = SQL_ERROR;
goto cleanup;
}
break;
}
}
-mylog("prepareParameters was %s called, prepare state:%d\n", shouldParse == nCallParse ? "" : "not", stmt->prepare);
+MYLOG(0, "prepareParameters was %s called, prepare state:%d\n", shouldParse == nCallParse ? "" : "not", stmt->prepare);
if (shouldParse == nCallParse &&
PREPARE_BY_THE_DRIVER == stmt->prepare)
/* Check for data at execution parameters */
if (apdopts->parameters[i].data_at_exec)
{
- mylog("The %dth parameter of %d-row is data at exec(%d)\n", i, current_row, pcVal ? (*pcVal) : -1);
+ MYLOG(0, "The " FORMAT_LEN "th parameter of " FORMAT_LEN "-row is data at exec(" FORMAT_LEN ")\n", i, current_row, pcVal ? (*pcVal) : -1);
if (stmt->data_at_exec < 0)
stmt->data_at_exec = 1;
else
goto next_param_row;
}
cleanup:
-mylog("retval=%d\n", retval);
+MYLOG(0, "retval=%d\n", retval);
SC_setInsertedTable(stmt, retval);
#undef return
return retval;
char ok;
int lf;
- mylog("entering %s: hdbc=%p, henv=%p\n", func, hdbc, henv);
+ MYLOG(0, "entering %s: hdbc=%p, henv=%p\n", func, 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("PGAPI_Transact: sending on conn %p '%d'\n", conn, fType);
+ MYLOG(0, "PGAPI_Transact: 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("%s: entering...\n", func);
+ MYLOG(0, "%s: entering...\n", func);
/* Check if this can handle canceling in the middle of a SQLPutData? */
if (!stmt)
ConnectionClass *conn = (ConnectionClass *) hdbc;
RETCODE result;
- mylog("%s: entering...cbSqlStrIn=%d\n", func, cbSqlStrIn);
+ MYLOG(0, "%s: entering...cbSqlStrIn=%d\n", func, cbSqlStrIn);
ptr = (cbSqlStrIn == 0) ? "" : make_string(szSqlStrIn, cbSqlStrIn, NULL, 0);
if (!ptr)
Int2 num_p;
ConnectionClass *conn = NULL;
- mylog("%s: entering...\n", func);
+ MYLOG(0, "%s: entering...\n", func);
conn = SC_get_conn(stmt);
estmt = stmt->execute_delegate ? stmt->execute_delegate : stmt;
apdopts = SC_get_APDF(estmt);
- mylog("%s: data_at_exec=%d, params_alloc=%d\n", func, estmt->data_at_exec, apdopts->allocated);
+ MYLOG(0, "%s: data_at_exec=%d, params_alloc=%d\n", func, estmt->data_at_exec, apdopts->allocated);
#define return DONT_CALL_RETURN_FROM_HERE???
if (SC_AcceptedCancelRequest(stmt))
/* Done, now copy the params and then execute the statement */
ipdopts = SC_get_IPDF(estmt);
-inolog("ipdopts=%p\n", ipdopts);
+MYLOG(1, "ipdopts=%p\n", ipdopts);
if (estmt->data_at_exec == 0)
{
BOOL exec_end;
num_p = estmt->num_params;
if (num_p < 0)
PGAPI_NumParams(estmt, &num_p);
-inolog("i=%d allocated=%d num_p=%d\n", i, apdopts->allocated, num_p);
+MYLOG(1, "i=%d allocated=%d num_p=%d\n", i, apdopts->allocated, num_p);
if (num_p > apdopts->allocated)
num_p = apdopts->allocated;
/* At least 1 data at execution parameter, so Fill in the token value */
for (; i < num_p; i++)
{
-inolog("i=%d", i);
+MYLOG(1, "i=%d", i);
if (apdopts->parameters[i].data_at_exec)
{
-inolog(" at exec buffer=%p", apdopts->parameters[i].buffer);
+MYLOG(1, " at exec buffer=%p", apdopts->parameters[i].buffer);
estmt->data_at_exec--;
estmt->current_exec_param = i;
estmt->put_data = FALSE;
SQLULEN offset = apdopts->param_offset_ptr ? *apdopts->param_offset_ptr : 0;
SQLLEN perrow = apdopts->param_bind_type > 0 ? apdopts->param_bind_type : apdopts->parameters[i].buflen;
-inolog(" offset=%d perrow=%d", offset, perrow);
+MYLOG(1, " offset=" FORMAT_LEN " perrow=" FORMAT_LEN, offset, perrow);
*prgbValue = apdopts->parameters[i].buffer + offset + estmt->exec_current_row * perrow;
}
else
}
break;
}
-inolog("\n");
+MYLOG(1, "\n");
}
retval = SQL_NEED_DATA;
-inolog("return SQL_NEED_DATA\n");
+MYLOG(1, "return SQL_NEED_DATA\n");
cleanup:
#undef return
SC_setInsertedTable(stmt, retval);
- mylog("%s: returning %d\n", func, retval);
+ MYLOG(0, "%s: returning %d\n", func, retval);
return retval;
}
SQLLEN putlen;
BOOL lenset = FALSE, handling_lo = FALSE;
- mylog("%s: entering...\n", func);
+ MYLOG(0, "%s: entering...\n", func);
#define return DONT_CALL_RETURN_FROM_HERE???
if (SC_AcceptedCancelRequest(stmt))
if (!estmt->put_data)
{ /* first call */
- mylog("PGAPI_PutData: (1) cbValue = %d\n", cbValue);
+ MYLOG(0, "PGAPI_PutData: (1) cbValue = " FORMAT_LEN "\n", cbValue);
estmt->put_data = TRUE;
}
retval = odbc_lo_write(conn, estmt->lobj_fd, putbuf, (Int4) putlen);
- mylog("lo_write: cbValue=%d, wrote %d bytes\n", putlen, retval);
+ MYLOG(0, "lo_write: cbValue=" FORMAT_LEN ", wrote %d bytes\n", putlen, retval);
}
else
{
else
{
/* calling SQLPutData more than once */
- mylog("PGAPI_PutData: (>1) cbValue = %d\n", cbValue);
+ MYLOG(0, "PGAPI_PutData: (>1) cbValue = " FORMAT_LEN "\n", cbValue);
/* if (current_iparam->SQLType == SQL_LONGVARBINARY) */
if (handling_lo)
{
/* the large object fd is in EXEC_buffer */
retval = odbc_lo_write(conn, estmt->lobj_fd, putbuf, (Int4) putlen);
- mylog("lo_write(2): cbValue = %d, wrote %d bytes\n", putlen, retval);
+ MYLOG(0, "lo_write(2): cbValue = " FORMAT_LEN ", wrote %d bytes\n", putlen, retval);
*current_pdata->EXEC_used += putlen;
}
char *buffer;
for (allocsize = (1 << 4); allocsize <= used; allocsize <<= 1) ;
- mylog(" cbValue = %d, old_pos = %d, *used = %d\n", putlen, old_pos, used);
+ MYLOG(0, " cbValue = " FORMAT_LEN ", old_pos = " FORMAT_LEN ", *used = " FORMAT_LEN "\n", putlen, old_pos, used);
/* dont lose the old pointer in case out of memory */
buffer = realloc(current_pdata->EXEC_buffer, allocsize);
RETCODE result = SQL_ERROR;
char odbcver[16];
- mylog("%s: entering...fInfoType=%d\n", func, fInfoType);
+ MYLOG(0, "%s: entering...fInfoType=%d\n", func, fInfoType);
if (!conn)
{
case SQL_CONVERT_VARCHAR: /* ODBC 1.0 */
len = sizeof(SQLUINTEGER);
value = SQL_CVT_BIT | SQL_CVT_INTEGER;
-mylog("SQL_CONVERT_ mask=" FORMAT_ULEN "\n", value);
+MYLOG(0, "SQL_CONVERT_ mask=" FORMAT_ULEN "\n", value);
break;
case SQL_CONVERT_BIGINT:
case SQL_CONVERT_DECIMAL:
case SQL_CONVERT_FUNCTIONS: /* ODBC 1.0 */
len = sizeof(SQLUINTEGER);
value = SQL_FN_CVT_CONVERT;
-mylog("CONVERT_FUNCTIONS=" FORMAT_ULEN "\n", value);
+MYLOG(0, "CONVERT_FUNCTIONS=" FORMAT_ULEN "\n", value);
break;
case SQL_CORRELATION_NAME: /* ODBC 1.0 */
result = SQL_SUCCESS;
- mylog("%s: p='%s', len=%d, value=%d, cbMax=%d\n", func, p ? p : "<NULL>", len, value, cbInfoValueMax);
+ MYLOG(0, "%s: p='%s', len=" FORMAT_ULEN ", value=" FORMAT_ULEN ", cbMax=%d\n", func, p ? p : "<NULL>", len, value, cbInfoValueMax);
/*
* NOTE, that if rgbInfoValue is NULL, then no warnings or errors
Int2 sqlType;
RETCODE result = SQL_SUCCESS;
- mylog("%s: entering...fSqlType = %d\n", func, fSqlType);
+ MYLOG(0, "%s: entering...fSqlType = %d\n", func, fSqlType);
if (result = SC_initialize_and_recycle(stmt), SQL_SUCCESS != result)
return result;
if (sqlType == SQL_LONGVARBINARY)
{
ConnInfo *ci = &(conn->connInfo);
-inolog("%d sqltype=%d -> pgtype=%d\n", ci->bytea_as_longvarbinary, sqlType, pgType);
+MYLOG(1, "%d sqltype=%d -> pgtype=%d\n", ci->bytea_as_longvarbinary, sqlType, pgType);
}
if (fSqlType == SQL_ALL_TYPES || fSqlType == sqlType)
/*if (SQL_INTEGER == sqlType || SQL_TINYINT == sqlType)*/
if (SQL_INTEGER == sqlType)
{
-mylog("sqlType=%d ms_jet=%d\n", sqlType, conn->ms_jet);
+MYLOG(0, "sqlType=%d ms_jet=%d\n", sqlType, conn->ms_jet);
if (conn->ms_jet)
{
aunq_match = 1;
pgtcount = 2;
}
-mylog("aunq_match=%d pgtcount=%d\n", aunq_match, pgtcount);
+MYLOG(0, "aunq_match=%d pgtcount=%d\n", aunq_match, pgtcount);
}
for (cnt = 0; cnt < pgtcount; cnt ++)
{
{
set_tuplefield_string(&tuple[GETTYPE_TYPE_NAME], PGTYPE_TO_NAME(conn, pgType, TRUE));
set_tuplefield_int2(&tuple[GETTYPE_NULLABLE], SQL_NO_NULLS);
-inolog("serial in\n");
+MYLOG(1, "serial in\n");
}
else
{
ConnectionClass *conn = (ConnectionClass *) hdbc;
ConnInfo *ci = &(conn->connInfo);
- mylog("%s: entering...%u\n", func, fFunction);
+ MYLOG(0, "%s: entering...%u\n", func, fFunction);
if (fFunction == SQL_API_ALL_FUNCTIONS)
{
srclen = (SQLLEN) strlen((char *) src);
if (srclen <= 0)
return dest;
-mylog("simple in=%s(%d)\n", src, srclen);
+MYLOG(0, "simple 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("simple output=%s(%d)\n", dest, outlen);
+MYLOG(0, "simple output=%s(%d)\n", dest, outlen);
return dest;
}
/* if (srclen <= 0) */
if (srclen < 0)
return dest;
-mylog("adjust in=%.*s(%d)\n", srclen, src, srclen);
+MYLOG(0, "adjust 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("adjust output=%s(%d)\n", dest, outlen);
+MYLOG(0, "adjust output=%s(%d)\n", dest, outlen);
return dest;
}
SQLLEN cbRelname, cbRelkind, cbSchName;
EnvironmentClass *env;
- mylog("%s: entering...stmt=%p scnm=%p len=%d\n", func, stmt, szTableOwner, cbTableOwner);
+ MYLOG(0, "%s: entering...stmt=%p scnm=%p len=%d\n", func, stmt, szTableOwner, cbTableOwner);
if (result = SC_initialize_and_recycle(stmt), SQL_SUCCESS != result)
return result;
/* Check extra system table prefixes */
for (i = 0; i < nprefixes; i++)
{
- mylog("table_name='%s', prefix[%d]='%s'\n", table_name, i, prefix[i]);
+ MYLOG(0, "table_name='%s', prefix[%d]='%s'\n", table_name, i, prefix[i]);
if (strncmp(table_name, prefix[i], strlen(prefix[i])) == 0)
{
systable = TRUE;
* set_tuplefield_string(&tuple[TABLES_SCHEMA_NAME], table_owner);
*/
- mylog("%s: table_name = '%s'\n", func, table_name);
+ MYLOG(0, "%s: table_name = '%s'\n", func, 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("%s: EXIT, stmt=%p, ret=%d\n", func, stmt, ret);
+ MYLOG(0, "%s: EXIT, stmt=%p, ret=%d\n", func, stmt, ret);
return ret;
}
const SQLCHAR *szSchemaName;
BOOL setIdentity = FALSE;
- mylog("%s: entering...stmt=%p scnm=%p len=%d\n", func, stmt, szTableOwner, cbTableOwner);
+ MYLOG(0, "%s: entering...stmt=%p scnm=%p len=%d\n", func, stmt, szTableOwner, cbTableOwner);
if (result = SC_initialize_and_recycle(stmt), SQL_SUCCESS != result)
return result;
}
col_stmt = (StatementClass *) hcol_stmt;
- mylog("%s: hcol_stmt = %p, col_stmt = %p\n", func, hcol_stmt, col_stmt);
+ MYLOG(0, "%s: hcol_stmt = %p, col_stmt = %p\n", func, hcol_stmt, col_stmt);
result = PGAPI_ExecDirect(hcol_stmt, (SQLCHAR *) columns_query.data, SQL_NTS, PODBC_RDONLY);
if (!SQL_SUCCEEDED(result))
PGAPI_GetData(hcol_stmt, 13, internal_asis_type, NULL, 0, &len_needed);
if (len_needed > 0)
{
-mylog("len_needed=%d\n", len_needed);
+MYLOG(0, "len_needed=" FORMAT_LEN "\n", len_needed);
attdef = malloc(len_needed + 1);
if (!attdef)
{
}
PGAPI_GetData(hcol_stmt, 13, internal_asis_type, attdef, len_needed + 1, &len_needed);
-mylog(" and the data=%s\n", attdef);
+MYLOG(0, " and the data=%s\n", attdef);
}
tuple = QR_AddNew(res);
free(escColumnName);
if (hcol_stmt)
PGAPI_FreeStmt(hcol_stmt, SQL_DROP);
- mylog("%s: EXIT, stmt=%p\n", func, stmt);
+ MYLOG(0, "%s: EXIT, stmt=%p\n", func, stmt);
return result;
}
const char *eq_string;
int result_cols;
- mylog("%s: entering...stmt=%p scnm=%p len=%d colType=%d scope=%d\n", func, stmt, szTableOwner, cbTableOwner, fColType, fScope);
+ MYLOG(0, "%s: entering...stmt=%p scnm=%p len=%d colType=%d scope=%d\n", func, stmt, szTableOwner, cbTableOwner, fColType, fScope);
if (result = SC_initialize_and_recycle(stmt), SQL_SUCCESS != result)
return result;
}
col_stmt = (StatementClass *) hcol_stmt;
- mylog("%s: hcol_stmt = %p, col_stmt = %p\n", func, hcol_stmt, col_stmt);
+ MYLOG(0, "%s: hcol_stmt = %p, col_stmt = %p\n", func, hcol_stmt, col_stmt);
if (PQExpBufferDataBroken(columns_query))
{
set_tuplefield_int4(&tuple[SPECOLS_BUFFER_LENGTH], PGTYPE_ATTR_BUFFER_LENGTH(conn, the_type, atttypmod));
set_tuplefield_int2(&tuple[SPECOLS_DECIMAL_DIGITS], PGTYPE_ATTR_DECIMAL_DIGITS(conn, the_type, atttypmod));
set_tuplefield_int2(&tuple[SPECOLS_PSEUDO_COLUMN], SQL_PC_NOT_PSEUDO);
-inolog("Add ctid\n");
+MYLOG(1, "Add ctid\n");
}
}
else
SC_set_current_col(stmt, -1);
if (hcol_stmt)
PGAPI_FreeStmt(hcol_stmt, SQL_DROP);
- mylog("%s: EXIT, stmt=%p\n", func, stmt);
+ MYLOG(0, "%s: EXIT, stmt=%p\n", func, stmt);
return result;
}
OID ioid;
Int4 relhasoids;
- mylog("%s: entering...stmt=%p scnm=%p len=%d\n", func, stmt, szTableOwner, cbTableOwner);
+ MYLOG(0, "%s: entering...stmt=%p scnm=%p len=%d\n", func, 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("%s: column_name = '%s'\n", func, column_name);
+ MYLOG(0, "%s: column_name = '%s'\n", func, column_name);
result = PGAPI_Fetch(hcol_stmt);
}
if (OID_ATTNUM == attnum)
{
set_tuplefield_string(&tuple[STATS_COLUMN_NAME], OID_NAME);
- mylog("%s: column name = oid\n", func);
+ MYLOG(0, "%s: column name = oid\n", func);
}
else if (0 == attnum)
{
if (unknownf)
{
set_tuplefield_string(&tuple[STATS_COLUMN_NAME], "UNKNOWN");
- mylog("%s: column name = UNKNOWN\n", func);
+ MYLOG(0, "%s: column name = UNKNOWN\n", func);
}
else
{
set_tuplefield_string(&tuple[STATS_COLUMN_NAME], column_names[matchidx].col_name);
- mylog("%s: column name = '%s'\n", func, column_names[matchidx].col_name);
+ MYLOG(0, "%s: column name = '%s'\n", func, column_names[matchidx].col_name);
}
}
SC_set_rowset_start(stmt, -1, FALSE);
SC_set_current_col(stmt, -1);
- mylog("%s: EXIT, stmt=%p, ret=%d\n", func, stmt, ret);
+ MYLOG(0, "%s: EXIT, stmt=%p, ret=%d\n", func, stmt, ret);
return ret;
}
BOOL search_pattern;
QResultClass *res = NULL;
- mylog("%s: entering...\n", func);
+ MYLOG(0, "%s: entering...\n", func);
/* Neither Access or Borland care about this. */
const char *eq_string;
char *escSchemaName = NULL, *escTableName = NULL;
- mylog("%s: entering...stmt=%p scnm=%p len=%d\n", func, stmt, szTableOwner, cbTableOwner);
+ MYLOG(0, "%s: entering...stmt=%p scnm=%p len=%d\n", func, stmt, szTableOwner, cbTableOwner);
if (result = SC_initialize_and_recycle(stmt), SQL_SUCCESS != result)
return result;
ret = SQL_ERROR;
goto cleanup;
}
- mylog("%s: tables_query='%s'\n", func, tables_query.data);
+ MYLOG(0, "%s: tables_query='%s'\n", func, tables_query.data);
result = PGAPI_ExecDirect(htbl_stmt, (SQLCHAR *) tables_query.data, SQL_NTS, PODBC_RDONLY);
if (!SQL_SUCCEEDED(result))
set_tuplefield_int2(&tuple[PKS_KEY_SQ], (Int2) (++seq));
set_tuplefield_string(&tuple[PKS_PK_NAME], pkname);
- mylog(">> primaryKeys: schema ='%s', pktab = '%s', attname = '%s', seq = %d\n", pkscm, pktbname, attname, seq);
+ MYLOG(0, ">> primaryKeys: schema ='%s', pktab = '%s', attname = '%s', seq = %d\n", pkscm, pktbname, attname, seq);
result = PGAPI_Fetch(htbl_stmt);
}
SC_set_rowset_start(stmt, -1, FALSE);
SC_set_current_col(stmt, -1);
- mylog("%s: EXIT, stmt=%p, ret=%d\n", func, stmt, ret);
+ MYLOG(0, "%s: EXIT, stmt=%p, ret=%d\n", func, stmt, ret);
return ret;
}
UInt4 relid1, relid2;
const char *eq_string;
- mylog("%s: entering...stmt=%p\n", func, stmt);
+ MYLOG(0, "%s: entering...stmt=%p\n", func, stmt);
if (result = SC_initialize_and_recycle(stmt), SQL_SUCCESS != result)
return result;
{
char *escSchemaName;
- mylog("%s: entering Foreign Key Case #2", func);
+ MYLOG(0, "%s: entering Foreign Key Case #2", func);
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);
/* Compute the number of keyparts. */
num_keys = (trig_nargs - 4) / 2;
- mylog("Foreign Key Case#2: trig_nargs = %d, num_keys = %d\n", trig_nargs, num_keys);
+ MYLOG(0, "Foreign Key Case#2: trig_nargs = %d, num_keys = %d\n", trig_nargs, num_keys);
/* If there is a pk table specified, then check it. */
if (pk_table_needed && pk_table_needed[0] != '\0')
got_pkname = TRUE;
}
pkey_text = getClientColumnName(conn, relid2, pkey_ptr, &pkey_alloced);
- mylog("%s: pkey_ptr='%s', pkey='%s'\n", func, pkey_text, pkey);
+ MYLOG(0, "%s: pkey_ptr='%s', pkey='%s'\n", func, 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("%s: pk_table = '%s', pkey_ptr = '%s'\n", func, pk_table_fetched, pkey_text);
+ MYLOG(0, "%s: pk_table = '%s', pkey_ptr = '%s'\n", func, 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("%s: fk_table_needed = '%s', fkey_ptr = '%s'\n", func, fk_table_needed, fkey_text);
+ MYLOG(0, "%s: fk_table_needed = '%s', fkey_ptr = '%s'\n", func, 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("%s: upd_rule_type = '%i', del_rule_type = '%i'\n, trig_name = '%s'", func, upd_rule_type, del_rule_type, trig_args);
+ MYLOG(0, "%s: upd_rule_type = '%i', del_rule_type = '%i'\n, trig_name = '%s'", func, 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);
else
defer_type = SQL_NOT_DEFERRABLE;
- mylog("Foreign Key Case#1: trig_nargs = %d, num_keys = %d\n", trig_nargs, num_keys);
+ MYLOG(0, "Foreign Key Case#1: trig_nargs = %d, num_keys = %d\n", trig_nargs, num_keys);
/* Get to first primary key */
pkey_ptr = trig_args;
pkey_text = getClientColumnName(conn, relid1, pkey_ptr, &pkey_alloced);
fkey_text = getClientColumnName(conn, relid2, fkey_ptr, &fkey_alloced);
- mylog("pkey_ptr = '%s', fk_table = '%s', fkey_ptr = '%s'\n", pkey_text, fk_table_fetched, fkey_text);
+ MYLOG(0, "pkey_ptr = '%s', fk_table = '%s', fkey_ptr = '%s'\n", pkey_text, fk_table_fetched, fkey_text);
tuple = QR_AddNew(res);
- mylog("pk_table_needed = '%s', pkey_ptr = '%s'\n", pk_table_needed, pkey_text);
+ MYLOG(0, "pk_table_needed = '%s', pkey_ptr = '%s'\n", pk_table_needed, pkey_text);
set_tuplefield_string(&tuple[FKS_PKTABLE_CAT], CurrCat(conn));
set_tuplefield_string(&tuple[FKS_PKTABLE_SCHEM], GET_SCHEMA_NAME(schema_needed));
set_tuplefield_string(&tuple[FKS_PKTABLE_NAME], pk_table_needed);
set_tuplefield_string(&tuple[FKS_PKCOLUMN_NAME], pkey_text);
- mylog("fk_table = '%s', fkey_ptr = '%s'\n", fk_table_fetched, fkey_text);
+ MYLOG(0, "fk_table = '%s', fkey_ptr = '%s'\n", fk_table_fetched, fkey_text);
set_tuplefield_string(&tuple[FKS_FKTABLE_CAT], CurrCat(conn));
set_tuplefield_string(&tuple[FKS_FKTABLE_SCHEM], GET_SCHEMA_NAME(schema_fetched));
set_tuplefield_string(&tuple[FKS_FKTABLE_NAME], fk_table_fetched);
set_tuplefield_int2(&tuple[FKS_KEY_SEQ], (Int2) (k + 1));
- mylog("upd_rule = %d, del_rule= %d", upd_rule_type, del_rule_type);
+ MYLOG(0, "upd_rule = %d, del_rule= %d", upd_rule_type, del_rule_type);
set_nullfield_int2(&tuple[FKS_UPDATE_RULE], upd_rule_type);
set_nullfield_int2(&tuple[FKS_DELETE_RULE], del_rule_type);
set_tuplefield_string(&tuple[FKS_TRIGGER_NAME], trig_args);
- mylog(" defer_type = %d\n", defer_type);
+ MYLOG(0, " defer_type = %d\n", defer_type);
set_tuplefield_int2(&tuple[FKS_DEFERRABILITY], defer_type);
if (pkey_alloced)
SC_set_rowset_start(stmt, -1, FALSE);
SC_set_current_col(stmt, -1);
- mylog("%s(): EXIT, stmt=%p, ret=%d\n", func, stmt, ret);
+ MYLOG(0, "%s(): EXIT, stmt=%p, ret=%d\n", func, 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("%s: entering...\n", func);
+ MYLOG(0, "%s: entering...\n", func);
if (result = SC_initialize_and_recycle(stmt), SQL_SUCCESS != result)
return result;
newpoid = 0;
if (poid_pos >= 0)
newpoid = QR_get_value_backend_int(tres, i, poid_pos, NULL);
-mylog("newpoid=%d\n", newpoid);
+MYLOG(0, "newpoid=%d\n", newpoid);
atttypid = NULL;
if (attid_pos >= 0)
{
atttypid = QR_get_value_backend_text(tres, i, attid_pos);
-mylog("atttypid=%s\n", atttypid ? atttypid : "(null)");
+MYLOG(0, "atttypid=%s\n", atttypid ? atttypid : "(null)");
}
if (poid == 0 || newpoid != poid)
{
const char *like_or_eq, *op_string;
BOOL search_pattern;
- mylog("%s: entering... scnm=%p len=%d\n", func, szProcOwner, cbProcOwner);
+ MYLOG(0, "%s: entering... scnm=%p len=%d\n", func, szProcOwner, cbProcOwner);
if (result = SC_initialize_and_recycle(stmt), SQL_SUCCESS != result)
return result;
{
int usercount = (int) QR_get_num_cached_tuples(allures), i, addcnt = 0;
-mylog("user=%s auth=%s\n", user, auth);
+MYLOG(0, "user=%s auth=%s\n", user, auth);
if (user[0])
for (i = 0; i < usercount; i++)
{
{
addcnt += usracl_auth(useracl[i], auth);
}
- mylog("addcnt=%d\n", addcnt);
+ MYLOG(0, "addcnt=%d\n", addcnt);
}
RETCODE SQL_API
char *escSchemaName = NULL, *escTableName = NULL;
BOOL search_pattern;
- mylog("%s: entering... scnm=%p len-%d\n", func, szTableOwner, cbTableOwner);
+ MYLOG(0, "%s: entering... scnm=%p len-%d\n", func, szTableOwner, cbTableOwner);
if (result = SC_initialize_and_recycle(stmt), SQL_SUCCESS != result)
return result;
*delm = '\0';
else if (delm = strchr(uid, '}'), delm)
*delm = '\0';
-mylog("guid=%s\n", uid);
+MYLOG(0, "guid=%s\n", uid);
for (i = 0; i < usercount; i++)
{
if (strcmp(QR_get_value_backend_text(allures, i, 1), uid) == 0)
set_tuplefield_string(&tuple[TABPRIV_GRANTOR], "_SYSTEM");
else
set_tuplefield_string(&tuple[TABPRIV_GRANTOR], owner);
- mylog("user=%s\n", user);
+ MYLOG(0, "user=%s\n", user);
set_tuplefield_string(&tuple[TABPRIV_GRANTEE], user);
switch (useracl[j][k])
{
const char *eq_string;
- mylog("%s: entering...stmt=%p\n", func, stmt);
+ MYLOG(0, "%s: entering...stmt=%p\n", func, stmt);
if (result = SC_initialize_and_recycle(stmt), SQL_SUCCESS != result)
return result;
*/
if (NULL != fk_table_needed)
{
- mylog("%s: entering Foreign Key Case #2", func);
+ MYLOG(0, "%s: entering Foreign Key Case #2", func);
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("%s(): EXIT, stmt=%p, ret=%d\n", func, stmt, ret);
+ MYLOG(0, "%s(): EXIT, stmt=%p, ret=%d\n", func, stmt, ret);
return ret;
}
tbsize++;
}
else
- mylog("%s:alloc %dbyte\n", ALCERR, size);
+ MYLOG(0, "%s:alloc %dbyte\n", ALCERR, size);
return alloced;
}
void * pgdebug_calloc(size_t n, size_t size)
tbsize++;
}
else
- mylog("%s:calloc %dbyte\n", ALCERR, size);
+ MYLOG(0, "%s:calloc %dbyte\n", ALCERR, size);
inolog("calloced = %p\n", alloced);
return alloced;
}
void * alloced = realloc(ptr, size);
if (!alloced)
{
- mylog("%s:%s %p error\n", ALCERR, __FUNCTION__, ptr);
+ MYLOG(0, "%s:%s %p error\n", ALCERR, __FUNCTION__, ptr);
}
else if (!ptr)
{
char * alloced = strdup(ptr);
if (!alloced)
{
- mylog("%s:%s %p error\n", ALCERR, __FUNCTION__, ptr);
+ MYLOG(0, "%s:%s %p error\n", ALCERR, __FUNCTION__, ptr);
}
else
{
if (!ptr)
{
- mylog("%s:%sing null ptr\n", ALCERR, __FUNCTION__);
+ MYLOG(0, "%s:%sing null ptr\n", ALCERR, __FUNCTION__);
return;
}
for (i = 0; i < tbsize; i++)
}
if (! freed)
{
- mylog("%s:%sing not found ptr %p\n", ALCERR, __FUNCTION__, ptr);
+ MYLOG(0, "%s:%sing not found ptr %p\n", ALCERR, __FUNCTION__, ptr);
return;
}
else
if ((UInt4)out + len > (UInt4)(altbl[i].aladr) + altbl[i].len)
{
ret = FALSE;
- mylog("%s:%s:out_check found memory buffer overrun %p(%d)>=%p(%d)\n", ALCERR, name, out, len, altbl[i].aladr, altbl[i].len);
+ MYLOG(0, "%s:%s:out_check found memory buffer overrun %p(%d)>=%p(%d)\n", ALCERR, name, out, len, altbl[i].aladr, altbl[i].len);
}
break;
}
{
if (!out || !in)
{
- mylog("%s:%s null pointer out=%p,in=%p\n", ALCERR, __FUNCTION__, out, in);
+ MYLOG(0, "%s:%s null pointer out=%p,in=%p\n", ALCERR, __FUNCTION__, out, in);
return NULL;
}
out_check(out, strlen(in) + 1, __FUNCTION__);
{
if (!out || !in)
{
- mylog("%s:%s null pointer out=%p,in=%p\n", ALCERR, __FUNCTION__, out, in);
+ MYLOG(0, "%s:%s null pointer out=%p,in=%p\n", ALCERR, __FUNCTION__, out, in);
return NULL;
}
out_check(out, len, __FUNCTION__);
{
if (!out || !in)
{
- mylog("%s:%s null pointer out=%p,in=%p\n", ALCERR, __FUNCTION__, out, in);
+ MYLOG(0, "%s:%s null pointer out=%p,in=%p\n", ALCERR, __FUNCTION__, out, in);
return NULL;
}
out_check(out, len, __FUNCTION__);
{
if (!out || !in)
{
- mylog("%s:%s null pointer out=%p,in=%p\n", ALCERR, __FUNCTION__, out, in);
+ MYLOG(0, "%s:%s null pointer out=%p,in=%p\n", ALCERR, __FUNCTION__, out, in);
return NULL;
}
out_check(out, len, __FUNCTION__);
{
if (!out)
{
- mylog("%s:%s null pointer out=%p\n", ALCERR, __FUNCTION__, out);
+ MYLOG(0, "%s:%s null pointer out=%p\n", ALCERR, __FUNCTION__, out);
return NULL;
}
out_check(out, len, __FUNCTION__);
if (0 == tbsize)
{
- mylog("no memry leak found and max count allocated so far is %d\n", alsize);
+ MYLOG(0, "no memry leak found and max count allocated so far is %d\n", alsize);
free(altbl);
alsize = 0;
}
else
{
- mylog("%s:memory leak found check count=%d alloc=%d\n", ALCERR, tbsize, alsize);
+ MYLOG(0, "%s:memory leak found check count=%d alloc=%d\n", ALCERR, tbsize, alsize);
for (i = 0; i < tbsize; i++)
{
- mylog("%s:leak = %p(%d)\n", ALCERR, altbl[i].aladr, altbl[i].len);
+ MYLOG(0, "%s:leak = %p(%d)\n", ALCERR, altbl[i].aladr, altbl[i].len);
}
}
}
if (_strnicmp(szFileName, sysdir, strlen(sysdir)) != 0)
{
hmodule = LoadLibraryEx(szFileName, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
- mylog("psqlodbc path based %s loaded module=%p\n", module_name, hmodule);
+ MYLOG(0, "psqlodbc path based %s loaded module=%p\n", module_name, hmodule);
}
}
return hmodule;
HMODULE hmodule = NULL;
const char* call_module = NULL;
- mylog("Dli%sHook %s Notify=%d\n", (dliFailLoadLib == dliNotify || dliFailGetProc == dliNotify) ? "Error" : "Notify", NULL != pdli->szDll ? pdli->szDll : pdli->dlp.szProcName, dliNotify);
+ MYLOG(0, "Dli%sHook %s Notify=%d\n", (dliFailLoadLib == dliNotify || dliFailGetProc == dliNotify) ? "Error" : "Notify", NULL != pdli->szDll ? pdli->szDll : pdli->dlp.szProcName, dliNotify);
switch (dliNotify)
{
case dliNotePreLoadLibrary:
{
if (enlist_module != NULL)
{
- mylog("Freeing Library %s\n", pgenlistdll);
+ MYLOG(0, "Freeing Library %s\n", pgenlistdll);
FreeLibrary(enlist_module);
}
- mylog("%s unloading\n", pgenlistdll);
+ MYLOG(0, "%s unloading\n", pgenlistdll);
success = (*func)(pgenlistdll);
- mylog("%s unloaded success=%d\n", pgenlistdll, success);
+ MYLOG(0, "%s unloaded success=%d\n", pgenlistdll, success);
loaded_pgenlist = FALSE;
}
if (loaded_psqlodbc)
{
- mylog("%s unloading\n", psqlodbcdll);
+ MYLOG(0, "%s unloading\n", psqlodbcdll);
success = (*func)(psqlodbcdll);
- mylog("%s unloaded success=%d\n", psqlodbcdll, success);
+ MYLOG(0, "%s unloaded success=%d\n", psqlodbcdll, success);
loaded_psqlodbc = FALSE;
}
return;
length = strlen((char *) s);
else
{
- mylog("make_string invalid length=%d\n", len);
+ MYLOG(0, "make_string invalid length=%d\n", len);
return NULL;
}
if (buf)
return buf;
}
-inolog("malloc size=%d\n", length);
+MYLOG(1, "malloc size=" FORMAT_SIZE_T "\n", length);
str = malloc(length + 1);
-inolog("str=%p\n", str);
+MYLOG(1, "str=%p\n", str);
if (!str)
return NULL;
return NULL;
memcpy(rptr, sptr, len);
rptr[len] = '\0';
- mylog("extracted a client_encoding '%s' from conn_settings\n", rptr);
+ MYLOG(0, "extracted a client_encoding '%s' from conn_settings\n", rptr);
return rptr;
}
ptr++;
if ((enc_no= pg_char_to_encoding(ptr)) >= 0)
wenc = pg_encoding_to_char(enc_no);
- mylog("%s locale=%s enc=%s\n", __FUNCTION__, loc, wenc ? wenc : "(null)");
+ MYLOG(0, "%s locale=%s enc=%s\n", __FUNCTION__, loc, wenc ? wenc : "(null)");
}
#endif /* WIN32 */
return wenc;
}
}
-DLL_DECLARE void
+DLL_DECLARE int
mylog(const char *fmt,...)
{
va_list args;
int gerrno;
- if (!mylog_on) return;
+ if (!mylog_on) return 0;
gerrno = GENERAL_ERRNO;
ENTER_MYLOG_CS;
va_end(args);
LEAVE_MYLOG_CS;
GENERAL_ERRNO_SET(gerrno);
+
+ return 1;
}
static void mylog_initialize(void)
{
static FILE *QLOGFP = NULL;
-void
+int
qlog(char *fmt,...)
{
va_list args;
char filebuf[80];
int gerrno;
- if (!qlog_on) return;
+ if (!qlog_on) return 0;
gerrno = GENERAL_ERRNO;
ENTER_QLOG_CS;
va_end(args);
LEAVE_QLOG_CS;
GENERAL_ERRNO_SET(gerrno);
+
+ return 1;
}
static void qlog_initialize(void)
{
extern "C" {
#endif
-DLL_DECLARE void mylog(const char *fmt,...);
-#define inolog if (get_mylog() > 1) mylog /* for really temporary debug */
+#ifndef __GNUC__
+#define __attribute__(x)
+#endif
+
+DLL_DECLARE int mylog(const char *fmt,...) __attribute__((format(printf, 1, 2)));
-extern void qlog(char *fmt,...);
-#define inoqlog if (get_qlog() > 1) qlog /* for really temporary debug */
+extern int qlog(char *fmt,...);
+
+#ifdef __GNUC__
+#define MYLOG(level, fmt, ...) (level < get_mylog() ? mylog((fmt), ##__VA_ARGS__) : 0)
+#elif defined WIN32 && _MSC_VER > 1800
+#define MYLOG(level, fmt, ...) (level < get_mylog() ? mylog(fmt, __VA_ARGS__) : (printf || printf((fmt), __VA_ARGS__)))
+#else
+#define MYLOG(level, ...) (level < get_mylog() ? mylog(__VA_ARGS__) : 0)
+#endif /* __GNUC__ */
int get_qlog(void);
int get_mylog(void);
RETCODE ret;
StatementClass *stmt = (StatementClass *) StatementHandle;
- mylog("[SQLBindCol]");
+ MYLOG(0, "[SQLBindCol]");
ENTER_STMT_CS(stmt);
SC_clear_error(stmt);
StartRollbackState(stmt);
RETCODE SQL_API
SQLCancel(HSTMT StatementHandle)
{
- mylog("[SQLCancel]");
+ MYLOG(0, "[SQLCancel]");
/* 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("[%s]", func);
+ MYLOG(0, "[%s]", func);
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
ConnectionClass *conn = (ConnectionClass *) ConnectionHandle;
- mylog("[SQLConnect]");
+ MYLOG(0, "[SQLConnect]");
CC_examine_global_transaction(conn);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
RETCODE ret;
ConnectionClass *conn = (ConnectionClass *) hdbc;
- mylog("[SQLDriverConnect]");
+ MYLOG(0, "[SQLDriverConnect]");
CC_examine_global_transaction(conn);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
RETCODE ret;
ConnectionClass *conn = (ConnectionClass *) hdbc;
- mylog("[SQLBrowseConnect]");
+ MYLOG(0, "[SQLBrowseConnect]");
CC_examine_global_transaction(conn);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
SQLCHAR *Description, SQLSMALLINT BufferLength2,
SQLSMALLINT *NameLength2)
{
- mylog("[SQLDataSources]");
+ MYLOG(0, "[SQLDataSources]");
/*
* return PGAPI_DataSources(EnvironmentHandle, Direction, ServerName,
RETCODE ret;
StatementClass *stmt = (StatementClass *) StatementHandle;
- mylog("[SQLDescribeCol]");
+ MYLOG(0, "[SQLDescribeCol]");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
ConnectionClass *conn = (ConnectionClass *) ConnectionHandle;
- mylog("[%s for %p]", func, ConnectionHandle);
+ MYLOG(0, "[%s for %p]", func, ConnectionHandle);
#ifdef _HANDLE_ENLIST_IN_DTC_
if (CC_is_in_global_trans(conn))
CALL_DtcOnDisconnect(conn);
StatementClass *stmt = (StatementClass *) StatementHandle;
UWORD flag = 0;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
StatementClass *stmt = (StatementClass *) StatementHandle;
UWORD flag = 0;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
SQLUSMALLINT *rowStatusArray = irdopts->rowStatusArray;
SQLULEN *pcRow = irdopts->rowsFetched;
- mylog("[[%s]]", func);
+ MYLOG(0, "[[%s]]", func);
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
StatementClass *stmt = (StatementClass *) StatementHandle;
ConnectionClass *conn = NULL;
- mylog("[SQLFreeStmt]");
+ MYLOG(0, "[SQLFreeStmt]");
if (stmt)
{
RETCODE ret;
StatementClass *stmt = (StatementClass *) StatementHandle;
- mylog("[SQLGetCursorName]");
+ MYLOG(0, "[SQLGetCursorName]");
ENTER_STMT_CS(stmt);
SC_clear_error(stmt);
StartRollbackState(stmt);
RETCODE ret;
StatementClass *stmt = (StatementClass *) StatementHandle;
- mylog("[SQLGetData]");
+ MYLOG(0, "[SQLGetData]");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
ConnectionClass *conn = (ConnectionClass *) ConnectionHandle;
- mylog("[SQLGetFunctions]");
+ MYLOG(0, "[SQLGetFunctions]");
CC_examine_global_transaction(conn);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
CC_examine_global_transaction(conn);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
- mylog("[%s(30)]", func);
+ MYLOG(0, "[%s(30)]", func);
if ((ret = PGAPI_GetInfo(ConnectionHandle, InfoType, InfoValue,
BufferLength, StringLength)) == SQL_ERROR)
CC_log_error("SQLGetInfo(30)", "", conn);
RETCODE ret;
StatementClass *stmt = (StatementClass *) StatementHandle;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
if (SC_connection_lost_check((StatementClass *) StatementHandle, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
StatementClass *stmt = (StatementClass *) StatementHandle;
- mylog("[SQLNumResultCols]");
+ MYLOG(0, "[SQLNumResultCols]");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
StatementClass *stmt = (StatementClass *) StatementHandle;
- mylog("[SQLParamData]");
+ MYLOG(0, "[SQLParamData]");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
StatementClass *stmt = (StatementClass *) StatementHandle;
- mylog("[SQLPrepare]");
+ MYLOG(0, "[SQLPrepare]");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
StatementClass *stmt = (StatementClass *) StatementHandle;
- mylog("[SQLPutData]");
+ MYLOG(0, "[SQLPutData]");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
StatementClass *stmt = (StatementClass *) StatementHandle;
- mylog("[SQLRowCount]");
+ MYLOG(0, "[SQLRowCount]");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
StatementClass *stmt = (StatementClass *) StatementHandle;
- mylog("[SQLSetCursorName]");
+ MYLOG(0, "[SQLSetCursorName]");
ENTER_STMT_CS(stmt);
SC_clear_error(stmt);
StartRollbackState(stmt);
SQLSMALLINT ParameterScale, PTR ParameterValue,
SQLLEN *StrLen_or_Ind)
{
- mylog("[SQLSetParam]");
+ MYLOG(0, "[SQLSetParam]");
SC_clear_error((StatementClass *) StatementHandle);
/*
StatementClass *stmt = (StatementClass *) StatementHandle;
SQLCHAR *ctName = CatalogName, *scName = SchemaName, *tbName = TableName;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
StatementClass *stmt = (StatementClass *) StatementHandle;
SQLCHAR *ctName = CatalogName, *scName = SchemaName, *tbName = TableName;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
SQLCHAR *ctName = CatalogName, *scName = SchemaName, *tbName = TableName;
UWORD flag = 0;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
*tbName = szTableName, *clName = szColumnName;
UWORD flag = 0;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
StatementClass *stmt = (StatementClass *) hstmt;
- mylog("[SQLDescribeParam]");
+ MYLOG(0, "[SQLDescribeParam]");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
StatementClass *stmt = (StatementClass *) hstmt;
- mylog("[SQLExtendedFetch]");
+ MYLOG(0, "[SQLExtendedFetch]");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
*pktbName = szPkTableName, *fkctName = szFkCatalogName,
*fkscName = szFkSchemaName, *fktbName = szFkTableName;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
StatementClass *stmt = (StatementClass *) hstmt;
- mylog("[SQLMoreResults]");
+ MYLOG(0, "[SQLMoreResults]");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
ConnectionClass *conn = (ConnectionClass *) hdbc;
- mylog("[SQLNativeSql]");
+ MYLOG(0, "[SQLNativeSql]");
CC_examine_global_transaction(conn);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
RETCODE ret;
StatementClass *stmt = (StatementClass *) hstmt;
- mylog("[SQLNumParams]");
+ MYLOG(0, "[SQLNumParams]");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
SQLCHAR *ctName = szCatalogName, *scName = szSchemaName,
*tbName = szTableName;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
*prName = szProcName, *clName = szColumnName;
UWORD flag = 0;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
*prName = szProcName;
UWORD flag = 0;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
StatementClass *stmt = (StatementClass *) hstmt;
- mylog("[SQLSetPos]");
+ MYLOG(0, "[SQLSetPos]");
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
*tbName = szTableName;
UWORD flag = 0;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
StatementClass *stmt = (StatementClass *) hstmt;
- mylog("[SQLBindParameter]");
+ MYLOG(0, "[SQLBindParameter]");
ENTER_STMT_CS(stmt);
SC_clear_error(stmt);
StartRollbackState(stmt);
RETCODE ret;
ConnectionClass *conn;
- mylog("[[%s]]", func);
+ MYLOG(0, "[[%s]]", func);
switch (HandleType)
{
case SQL_HANDLE_ENV:
ENTER_CONN_CS(conn);
ret = PGAPI_AllocDesc(InputHandle, OutputHandle);
LEAVE_CONN_CS(conn);
-inolog("OutputHandle=%p\n", *OutputHandle);
+MYLOG(1, "OutputHandle=%p\n", *OutputHandle);
break;
default:
ret = SQL_ERROR;
StatementClass *stmt = (StatementClass *) StatementHandle;
int BufferLength = 512; /* Is it OK ? */
- mylog("[[%s]]", func);
+ MYLOG(0, "[[%s]]", func);
ENTER_STMT_CS(stmt);
SC_clear_error(stmt);
StartRollbackState(stmt);
StatementClass *stmt = (StatementClass *) StatementHandle;
RETCODE ret;
- mylog("[[%s]]", func);
+ MYLOG(0, "[[%s]]", func);
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
StatementClass *stmt = (StatementClass *) StatementHandle;
- mylog("[[%s]]", func);
+ MYLOG(0, "[[%s]]", func);
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
CSTR func = "SQLCopyDesc";
RETCODE ret;
- mylog("[[%s]]\n", func);
+ MYLOG(0, "[[%s]]\n", func);
ret = PGAPI_CopyDesc(SourceDescHandle, TargetDescHandle);
return ret;
}
CSTR func = "SQLEndTran";
RETCODE ret;
- mylog("[[%s]]", func);
+ MYLOG(0, "[[%s]]", func);
switch (HandleType)
{
case SQL_HANDLE_ENV:
SQLULEN *pcRow = irdopts->rowsFetched;
SQLLEN bkmarkoff = 0;
- mylog("[[%s]] %d,%d\n", func, FetchOrientation, FetchOffset);
+ MYLOG(0, "[[%s]] %d," FORMAT_LEN "\n", func, FetchOrientation, FetchOffset);
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
{
bkmarkoff = FetchOffset;
FetchOffset = *((Int4 *) stmt->options.bookmark_ptr);
-mylog("bookmark=%u FetchOffset = %d\n", FetchOffset, bkmarkoff);
+MYLOG(0, "bookmark=" FORMAT_LEN " FetchOffset = " FORMAT_LEN "\n", FetchOffset, bkmarkoff);
}
else
{
ret = DiscardStatementSvp(stmt,ret, FALSE);
LEAVE_STMT_CS(stmt);
if (ret != SQL_SUCCESS)
- mylog("%s return = %d\n", func, ret);
+ MYLOG(0, "%s return = %d\n", func, ret);
return ret;
}
StatementClass *stmt;
ConnectionClass *conn = NULL;
- mylog("[[%s]]", func);
+ MYLOG(0, "[[%s]]", func);
switch (HandleType)
{
{
RETCODE ret;
- mylog("[[SQLGetDescField]]\n");
+ MYLOG(0, "[[SQLGetDescField]]\n");
ret = PGAPI_GetDescField(DescriptorHandle, RecNumber, FieldIdentifier,
Value, BufferLength, StringLength);
return ret;
SQLLEN *Length, SQLSMALLINT *Precision,
SQLSMALLINT *Scale, SQLSMALLINT *Nullable)
{
- mylog("[[SQLGetDescRec]]\n");
- mylog("Error not implemented\n");
+ MYLOG(0, "[[SQLGetDescRec]]\n");
+ MYLOG(0, "Error not implemented\n");
return SQL_ERROR;
}
CSTR func = "SQLGetDiagField";
RETCODE ret;
- mylog("[[%s]] Handle=(%u,%p) Rec=%d Id=%d info=(%p,%d)\n", func, HandleType, Handle, RecNumber, DiagIdentifier, DiagInfo, BufferLength);
+ MYLOG(0, "[[%s]] Handle=(%u,%p) Rec=%d Id=%d info=(%p,%d)\n", func, HandleType, Handle, RecNumber, DiagIdentifier, DiagInfo, BufferLength);
ret = PGAPI_GetDiagField(HandleType, Handle, RecNumber, DiagIdentifier,
DiagInfo, BufferLength, StringLength);
return ret;
{
RETCODE ret;
- mylog("[[SQLGetDiagRec]]\n");
+ MYLOG(0, "[[SQLGetDiagRec]]\n");
ret = PGAPI_GetDiagRec(HandleType, Handle, RecNumber, Sqlstate,
NativeError, MessageText, BufferLength, TextLength);
return ret;
RETCODE ret;
EnvironmentClass *env = (EnvironmentClass *) EnvironmentHandle;
- mylog("[[SQLGetEnvAttr]] %d\n", Attribute);
+ MYLOG(0, "[[SQLGetEnvAttr]] %d\n", Attribute);
ENTER_ENV_CS(env);
ret = SQL_SUCCESS;
switch (Attribute)
{
RETCODE ret;
- mylog("[[SQLGetConnectAttr]] %d\n", Attribute);
+ MYLOG(0, "[[SQLGetConnectAttr]] %d\n", Attribute);
CC_examine_global_transaction((ConnectionClass*) ConnectionHandle);
ENTER_CONN_CS((ConnectionClass *) ConnectionHandle);
CC_clear_error((ConnectionClass *) ConnectionHandle);
CSTR func = "SQLGetStmtAttr";
StatementClass *stmt = (StatementClass *) StatementHandle;
- mylog("[[%s]] Handle=%u %d\n", func, StatementHandle, Attribute);
+ MYLOG(0, "[[%s]] Handle=%p %d\n", func, StatementHandle, Attribute);
ENTER_STMT_CS(stmt);
SC_clear_error(stmt);
StartRollbackState(stmt);
RETCODE ret;
ConnectionClass *conn = (ConnectionClass *) ConnectionHandle;
- mylog("[[SQLSetConnectAttr]] %d\n", Attribute);
+ MYLOG(0, "[[SQLSetConnectAttr]] %d\n", Attribute);
CC_examine_global_transaction(conn);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
{
RETCODE ret;
- mylog("[[SQLSetDescField]] h=%p rec=%d field=%d val=%p\n", DescriptorHandle, RecNumber, FieldIdentifier, Value);
+ MYLOG(0, "[[SQLSetDescField]] h=%p rec=%d field=%d val=%p\n", DescriptorHandle, RecNumber, FieldIdentifier, Value);
ret = PGAPI_SetDescField(DescriptorHandle, RecNumber, FieldIdentifier,
Value, BufferLength);
return ret;
{
CSTR func = "SQLSetDescRec";
- mylog("[[%s]]\n", func);
- mylog("Error not implemented\n");
+ MYLOG(0, "[[%s]]\n", func);
+ MYLOG(0, "Error not implemented\n");
return SQL_ERROR;
}
#endif /* UNICODE_SUPPORTXX */
RETCODE ret;
EnvironmentClass *env = (EnvironmentClass *) EnvironmentHandle;
- mylog("[[SQLSetEnvAttr]] att=%d,%u\n", Attribute, Value);
+ MYLOG(0, "[[SQLSetEnvAttr]] att=%d," FORMAT_ULEN "\n", Attribute, (SQLULEN) Value);
ENTER_ENV_CS(env);
switch (Attribute)
{
StatementClass *stmt = (StatementClass *) StatementHandle;
RETCODE ret;
- mylog("[[%s]] Handle=%p %d,%u\n", func, StatementHandle, Attribute, Value);
+ MYLOG(0, "[[%s]] Handle=%p %d," FORMAT_ULEN "\n", func, StatementHandle, Attribute, (SQLULEN) Value);
ENTER_STMT_CS(stmt);
SC_clear_error(stmt);
StartRollbackState(stmt);
ConnectionClass *conn = (ConnectionClass *) hdbc;
ConnInfo *ci = &(conn->connInfo);
-inolog("lie=%d\n", ci->drivers.lie);
+MYLOG(1, "lie=%d\n", ci->drivers.lie);
CC_examine_global_transaction(conn);
CC_clear_error(conn);
if (fFunction != SQL_API_ODBC3_ALL_FUNCTIONS)
return SQL_ERROR;
ENTER_STMT_CS(stmt);
- mylog("[[%s]] Handle=%p %d\n", func, hstmt, operation);
+ MYLOG(0, "[[%s]] Handle=%p %d\n", func, hstmt, operation);
SC_clear_error(stmt);
StartRollbackState(stmt);
ret = PGAPI_BulkOperations(hstmt, operation);
RETCODE ret;
StatementClass *stmt = (StatementClass *) hstmt;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
ENTER_STMT_CS((StatementClass *) hstmt);
SC_clear_error((StatementClass *) hstmt);
StartRollbackState(stmt);
RETCODE ret;
StatementClass *stmt = (StatementClass *) hstmt;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
ENTER_STMT_CS(stmt);
SC_clear_error(stmt);
StartRollbackState(stmt);
CSTR func = "SQLGetConnectAttrW";
RETCODE ret;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
CC_examine_global_transaction((ConnectionClass *) hdbc);
ENTER_CONN_CS((ConnectionClass *) hdbc);
CC_clear_error((ConnectionClass *) hdbc);
RETCODE ret;
ConnectionClass *conn = (ConnectionClass *) hdbc;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
CC_examine_global_transaction(conn);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
char *uval = NULL;
BOOL val_alloced = FALSE;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
if (BufferLength > 0 || SQL_NTS == BufferLength)
{
switch (FieldIdentifier)
SQLINTEGER blen = 0, bMax, *pcbV;
char *rgbV = NULL, *rgbVt;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
switch (iField)
{
case SQL_DESC_BASE_COLUMN_NAME:
SQLSMALLINT buflen, tlen;
char qstr_ansi[8], *mtxt = NULL;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
buflen = 0;
if (szErrorMsg && cbErrorMsgMax > 0)
{
SQLSMALLINT *rgbL, blen = 0, bMax;
char *rgbD = NULL, *rgbDt;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
SQLSMALLINT *rgbL, blen = 0, bMax;
char *rgbD = NULL, *rgbDt;
- mylog("[[%s]] Handle=(%u,%p) Rec=%d Id=%d info=(%p,%d)\n", func, fHandleType,
+ MYLOG(0, "[[%s]] Handle=(%u,%p) Rec=%d Id=%d info=(%p,%d)\n", func, fHandleType,
handle, iRecord, fDiagField, rgbDiagInfo, cbDiagInfoMax);
switch (fDiagField)
{
SQLLEN *Length, SQLSMALLINT *Precision,
SQLSMALLINT *Scale, SQLSMALLINT *Nullable)
{
- mylog("[[SQLGetDescRecW]]\n");
- mylog("Error not implemented\n");
+ MYLOG(0, "[[SQLGetDescRecW]]\n");
+ MYLOG(0, "Error not implemented\n");
return SQL_ERROR;
}
{
CSTR func = "SQLSetDescRecW";
- mylog("[[%s]]\n", func);
- mylog("Error not implemented\n");
+ MYLOG(0, "[[%s]]\n", func);
+ MYLOG(0, "Error not implemented\n");
return SQL_ERROR;
}
UWORD flag = PODBC_SEARCH_PUBLIC_SCHEMA;
ConnInfo *ci;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
ConnectionClass *conn = (ConnectionClass *) ConnectionHandle;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
CC_examine_global_transaction(conn);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
RETCODE ret;
ConnectionClass *conn = (ConnectionClass *) hdbc;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
CC_examine_global_transaction(conn);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
utf8_to_ucs2(szOut, maxlen, szConnStrOut, cbConnStrOutMax);
if (outlen >= cbConnStrOutMax && NULL != szConnStrOut && NULL != pcbConnStrOut)
{
-inolog("cbConnstrOutMax=%d pcb=%p\n", cbConnStrOutMax, pcbConnStrOut);
+MYLOG(1, "cbConnstrOutMax=%d pcb=%p\n", cbConnStrOutMax, pcbConnStrOut);
if (SQL_SUCCESS == ret)
{
CC_set_error(conn, CONN_TRUNCATED, "the ConnStrOut is too small", func);
RETCODE ret;
ConnectionClass *conn = (ConnectionClass *) hdbc;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
CC_examine_global_transaction(conn);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
SQLSMALLINT *NameLength2)
{
CSTR func = "SQLDataSourcesW";
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
/*
return PGAPI_DataSources(EnvironmentHandle, Direction, ServerName,
BufferLength1, NameLength1, Description, BufferLength2,
SQLSMALLINT buflen, nmlen;
char *clName = NULL, *clNamet = NULL;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
StatementClass *stmt = (StatementClass *) StatementHandle;
UWORD flag = 0;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
char *crName = NULL, *crNamet;
SQLSMALLINT clen, buflen;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
if (BufferLength > 0)
buflen = BufferLength * 3;
else
ENTER_CONN_CS(conn);
CC_set_in_unicode_driver(conn);
CC_clear_error(conn);
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
if ((ret = PGAPI_GetInfo(ConnectionHandle, InfoType, InfoValue,
BufferLength, StringLength)) == SQL_ERROR)
CC_log_error("SQLGetInfoW", "", conn);
char *stxt;
SQLLEN slen;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
char *crName;
SQLLEN nlen;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
crName = ucs2_to_utf8(CursorName, NameLength, &nlen, FALSE);
ENTER_STMT_CS(stmt);
SC_clear_error(stmt);
ConnectionClass *conn;
BOOL lower_id;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
ConnectionClass *conn;
BOOL lower_id;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
BOOL lower_id;
UWORD flag = 0;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
BOOL lower_id;
UWORD flag = 0;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
ConnectionClass *conn;
BOOL lower_id;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
SQLINTEGER buflen, olen;
ConnectionClass *conn = (ConnectionClass *) hdbc;
- mylog("[%s}", func);
+ MYLOG(0, "[%s}", func);
CC_examine_global_transaction(conn);
ENTER_CONN_CS(conn);
CC_clear_error(conn);
ConnectionClass *conn;
BOOL lower_id;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
BOOL lower_id;
UWORD flag = 0;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
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("[%s]", func);
+ MYLOG(0, "[%s]", func);
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
BOOL lower_id;
UWORD flag = 0;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
RETCODE ret;
StatementClass * stmt = (StatementClass *) StatementHandle;
- mylog("[%s]", func);
+ MYLOG(0, "[%s]", func);
if (SC_connection_lost_check(stmt, __FUNCTION__))
return SQL_ERROR;
* positioned update isn't supported so cursor concurrency is
* read-only
*/
- mylog("SetStmtOption(): SQL_CONCURRENCY = " FORMAT_LEN " ", vParam);
+ MYLOG(0, "SetStmtOption(): SQL_CONCURRENCY = " FORMAT_LEN " ", vParam);
setval = SQL_CONCUR_READ_ONLY;
if (SQL_CONCUR_READ_ONLY == vParam)
;
}
if (setval != vParam)
changed = TRUE;
- mylog("-> " FORMAT_LEN "\n", setval);
+ MYLOG(0, "-> " FORMAT_LEN "\n", setval);
break;
case SQL_CURSOR_TYPE:
* if declare/fetch, then type can only be forward. otherwise,
* it can only be forward or static.
*/
- mylog("SetStmtOption(): SQL_CURSOR_TYPE = " FORMAT_LEN " ", vParam);
+ MYLOG(0, "SetStmtOption(): SQL_CURSOR_TYPE = " FORMAT_LEN " ", vParam);
setval = SQL_CURSOR_FORWARD_ONLY;
if (ci->drivers.lie)
setval = vParam;
}
if (setval != vParam)
changed = TRUE;
- mylog("-> " FORMAT_LEN "\n", setval);
+ MYLOG(0, "-> " FORMAT_LEN "\n", setval);
break;
case SQL_KEYSET_SIZE: /* ignored, but saved and returned */
- mylog("SetStmtOption(): SQL_KEYSET_SIZE, vParam = " FORMAT_LEN "\n", vParam);
+ MYLOG(0, "SetStmtOption(): SQL_KEYSET_SIZE, vParam = " FORMAT_LEN "\n", vParam);
if (conn)
conn->stmtOptions.keyset_size = vParam;
break;
case SQL_MAX_LENGTH: /* ignored, but saved */
- mylog("SetStmtOption(): SQL_MAX_LENGTH, vParam = " FORMAT_LEN "\n", vParam);
+ MYLOG(0, "SetStmtOption(): 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("SetStmtOption(): SQL_MAX_ROWS, vParam = " FORMAT_LEN "\n", vParam);
+ MYLOG(0, "SetStmtOption(): SQL_MAX_ROWS, vParam = " FORMAT_LEN "\n", vParam);
if (conn)
conn->stmtOptions.maxRows = vParam;
if (stmt)
break;
case SQL_NOSCAN: /* ignored */
- mylog("SetStmtOption: SQL_NOSCAN, vParam = " FORMAT_LEN "\n", vParam);
+ MYLOG(0, "SetStmtOption: SQL_NOSCAN, vParam = " FORMAT_LEN "\n", vParam);
break;
case SQL_QUERY_TIMEOUT: /* ignored */
- mylog("SetStmtOption: SQL_QUERY_TIMEOUT, vParam = " FORMAT_LEN "\n", vParam);
+ MYLOG(0, "SetStmtOption: SQL_QUERY_TIMEOUT, vParam = " FORMAT_LEN "\n", vParam);
if (conn)
conn->stmtOptions.stmt_timeout = (SQLULEN) vParam;
if (stmt)
break;
case SQL_RETRIEVE_DATA:
- mylog("SetStmtOption(): SQL_RETRIEVE_DATA, vParam = " FORMAT_LEN "\n", vParam);
+ MYLOG(0, "SetStmtOption(): SQL_RETRIEVE_DATA, vParam = " FORMAT_LEN "\n", vParam);
if (conn)
conn->stmtOptions.retrieve_data = (SQLUINTEGER) vParam;
if (stmt)
break;
case SQL_ROWSET_SIZE:
- mylog("SetStmtOption(): SQL_ROWSET_SIZE, vParam = " FORMAT_LEN "\n", vParam);
+ MYLOG(0, "SetStmtOption(): SQL_ROWSET_SIZE, vParam = " FORMAT_LEN "\n", vParam);
if (vParam < 1)
{
case SQL_USE_BOOKMARKS:
if (stmt)
{
- mylog("USE_BOOKMARKS %s\n", (vParam == SQL_UB_OFF) ? "off" : ((vParam == SQL_UB_VARIABLE) ? "variable" : "fixed"));
+ MYLOG(0, "USE_BOOKMARKS %s\n", (vParam == SQL_UB_OFF) ? "off" : ((vParam == SQL_UB_VARIABLE) ? "variable" : "fixed"));
setval = vParam;
stmt->options.use_bookmarks = (SQLUINTEGER) setval;
}
RETCODE retval;
BOOL autocomm_on;
- mylog("%s: entering fOption = %d vParam = " FORMAT_LEN "\n", func, fOption, vParam);
+ MYLOG(0, "%s: entering fOption = %d vParam = " FORMAT_LEN "\n", func, 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("%s: AUTOCOMMIT: transact_status=%d, vparam=" FORMAT_LEN "\n", func, conn->transact_status, vParam);
+ MYLOG(0, "%s: AUTOCOMMIT: transact_status=%d, vparam=" FORMAT_LEN "\n", func, conn->transact_status, vParam);
#ifdef _HANDLE_ENLIST_IN_DTC_
if (CC_is_in_global_trans(conn))
cmp = strncmp((char *) vParam, "Microsoft Jet", 13);
if (0 == cmp)
{
- mylog("Microsoft Jet !!!!\n");
+ MYLOG(0, "Microsoft Jet !!!!\n");
CC_set_errornumber(conn, 0);
conn->ms_jet = 1;
return SQL_SUCCESS;
SQLLEN len = sizeof(SQLINTEGER);
SQLRETURN result = SQL_SUCCESS;
- mylog("%s: entering...\n", func);
+ MYLOG(0, "%s: entering...\n", func);
if (!conn)
{
#else
case 1209:
#endif /* SQL_ATTR_CONNECTION_DEAD */
- mylog("CONNECTION_DEAD status=%d", conn->status);
+ MYLOG(0, "CONNECTION_DEAD status=%d", conn->status);
*((SQLUINTEGER *) pvParam) = CC_not_connected(conn);
- mylog(" val=%d\n", *((SQLUINTEGER *) pvParam));
+ MYLOG(0, " val=%d\n", *((SQLUINTEGER *) pvParam));
break;
case SQL_ATTR_ANSI_APP:
*((SQLUINTEGER *) pvParam) = CC_is_in_ansi_app(conn);
- mylog("ANSI_APP val=%d\n", *((SQLUINTEGER *) pvParam));
+ MYLOG(0, "ANSI_APP val=%d\n", *((SQLUINTEGER *) pvParam));
break;
/* These options should be handled by driver manager */
StatementClass *stmt = (StatementClass *) hstmt;
RETCODE retval;
- mylog("%s: entering...\n", func);
+ MYLOG(0, "%s: entering...\n", func);
/*
* Though we could fake Access out by just returning SQL_SUCCESS all
SQLINTEGER len = sizeof(SQLINTEGER);
Int4 bookmark;
- mylog("%s: entering...\n", func);
+ MYLOG(0, "%s: entering...\n", func);
/*
* thought we could fake Access out by just returning SQL_SUCCESS all
break;
case SQL_CONCURRENCY: /* NOT REALLY SUPPORTED */
- mylog("GetStmtOption(): SQL_CONCURRENCY %d\n", stmt->options.scroll_concurrency);
+ MYLOG(0, "GetStmtOption(): SQL_CONCURRENCY %d\n", stmt->options.scroll_concurrency);
*((SQLINTEGER *) pvParam) = stmt->options.scroll_concurrency;
break;
case SQL_CURSOR_TYPE: /* PARTIAL SUPPORT */
- mylog("GetStmtOption(): SQL_CURSOR_TYPE %d\n", stmt->options.cursor_type);
+ MYLOG(0, "GetStmtOption(): 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("GetStmtOption(): SQL_KEYSET_SIZE\n");
+ MYLOG(0, "GetStmtOption(): 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("GetSmtOption: MAX_ROWS, returning %d\n", stmt->options.maxRows);
+ MYLOG(0, "GetSmtOption: MAX_ROWS, returning " FORMAT_LEN "\n", stmt->options.maxRows);
break;
case SQL_NOSCAN: /* NOT SUPPORTED */
/* skip leading delimiters */
while (isspace((UCHAR) s[i]) || s[i] == ',')
{
- /* mylog("skipping '%c'\n", s[i]); */
+ /* MYLOG(0, "skipping '%c'\n", s[i]); */
i++;
}
if (ispunct((UCHAR) s[i]) && s[i] != '_')
{
- mylog("got ispunct: s[%d] = '%c'\n", i, s[i]);
+ MYLOG(0, "got ispunct: s[" FORMAT_SIZE_T "] = '%c'\n", i, s[i]);
if (out == 0)
{
i++;
}
- /* mylog("done -- s[%d] = '%c'\n", i, s[i]); */
+ /* MYLOG(0, "done -- s[%d] = '%c'\n", i, s[i]); */
token[out] = '\0';
{
char *str;
-inolog("getColInfo non-manual result\n");
+MYLOG(1, "getColInfo 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;
-inolog("searchColInfo num_cols=%d col=%s\n", QR_get_num_cached_tuples(col_info->result), PRINT_NAME(fi->column_name));
+MYLOG(1, "searchColInfo 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);
-inolog("searchColInfo %d attnum=%d\n", k, attnum);
+MYLOG(1, "searchColInfo %d attnum=%d\n", k, attnum);
if (attnum == fi->attnum &&
basetype == fi->basetype &&
atttypmod == fi->typmod)
{
getColInfo(col_info, fi, k);
- mylog("PARSE: searchColInfo by attnum=%d\n", attnum);
+ MYLOG(0, "PARSE: searchColInfo by attnum=%d\n", attnum);
return TRUE;
}
}
else if (NAME_IS_VALID(fi->column_name))
{
col = QR_get_value_backend_text(col_info->result, k, COLUMNS_COLUMN_NAME);
-inolog("searchColInfo %d col=%s\n", k, col);
+MYLOG(1, "searchColInfo %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("PARSE: searchColInfo: \n");
+ MYLOG(0, "PARSE: searchColInfo: \n");
return TRUE;
}
}
BOOL multi_table = FALSE;
QResultClass *res;
-inolog("has_multi_table ntab=%d", stmt->ntab);
+MYLOG(1, "has_multi_table ntab=%d", stmt->ntab);
if (1 < stmt->ntab)
multi_table = TRUE;
else if (SC_has_join(stmt))
reloid = greloid;
else if (reloid != greloid)
{
-inolog(" dohhhhhh");
+MYLOG(1, " dohhhhhh");
multi_table = TRUE;
break;
}
}
}
}
-inolog(" multi=%d\n", multi_table);
+MYLOG(1, " multi=%d\n", multi_table);
return multi_table;
}
/*
int i, num_fields;
BOOL fi_reuse, updatable, call_xxxxx;
-mylog("ColAttSet in\n");
+MYLOG(0, "ColAttSet in\n");
if (reloid = rti->table_oid, 0 == reloid)
return FALSE;
}
setNumFields(irdflds, num_fields);
updatable = TI_is_updatable(rti);
-mylog("updatable=%d tab=%d fields=%d", updatable, stmt->ntab, num_fields);
+MYLOG(0, "updatable=%d tab=%d fields=%d", updatable, stmt->ntab, num_fields);
if (updatable)
{
if (1 > stmt->ntab)
else if (has_multi_table(stmt))
updatable = FALSE;
}
-mylog("->%d\n", updatable);
+MYLOG(0, "->%d\n", updatable);
if (stmt->updatable < 0)
SC_set_updatable(stmt, updatable);
for (i = 0; i < num_fields; i++)
if (!NAMEICMP(conn->col_info[colidx]->table_name, table_name) &&
!stricmp(SAFE_NAME(conn->col_info[colidx]->schema_name), curschema))
{
- mylog("FOUND col_info table='%s' current schema='%s'\n", PRINT_NAME(table_name), curschema);
+ MYLOG(0, "FOUND col_info table='%s' current schema='%s'\n", PRINT_NAME(table_name), curschema);
found = TRUE;
STR_TO_NAME(*schema_name, curschema);
break;
if (!NAMEICMP(conn->col_info[colidx]->table_name, table_name) &&
!NAMEICMP(conn->col_info[colidx]->schema_name, *schema_name))
{
- mylog("FOUND col_info table='%s' schema='%s'\n", PRINT_NAME(table_name), PRINT_NAME(*schema_name));
+ MYLOG(0, "FOUND col_info table='%s' schema='%s'\n", PRINT_NAME(table_name), PRINT_NAME(*schema_name));
found = TRUE;
break;
}
StatementClass *col_stmt;
QResultClass *res;
- mylog("PARSE: Getting PG_Columns for table %u(%s)\n", greloid, PRINT_NAME(wti->table_name));
+ MYLOG(0, "PARSE: Getting PG_Columns for table %u(%s)\n", greloid, PRINT_NAME(wti->table_name));
if (NULL == conn)
conn = SC_get_conn(stmt);
NULL, 0,
PODBC_NOT_SEARCH_PATTERN, 0, 0);
- mylog(" Past PG_Columns\n");
+ MYLOG(0, " Past PG_Columns\n");
res = SC_get_Curres(col_stmt);
if (SQL_SUCCEEDED(result)
&& res != NULL && QR_get_num_cached_tuples(res) > 0)
int k;
time_t acctime = 0;
- mylog(" Success\n");
+ MYLOG(0, " Success\n");
if (greloid != 0)
{
for (k = 0; k < conn->ntables; k++)
new_alloc = conn->coli_allocated * 2;
if (new_alloc <= conn->ntables)
new_alloc = COLI_INCR;
- mylog("PARSE: Allocating col_info at ntables=%d\n", conn->ntables);
+ MYLOG(0, "PARSE: Allocating col_info at ntables=%d\n", conn->ntables);
col_info = (COL_INFO **) realloc(conn->col_info, new_alloc * sizeof(COL_INFO *));
if (!col_info)
conn->coli_allocated = new_alloc;
}
- mylog("PARSE: malloc at conn->col_info[%d]\n", conn->ntables);
+ MYLOG(0, "PARSE: malloc at conn->col_info[%d]\n", conn->ntables);
coli = conn->col_info[conn->ntables] = (COL_INFO *) malloc(sizeof(COL_INFO));
}
if (!coli)
STR_TO_NAME(wti->table_name,
QR_get_value_backend_text(res, 0, COLUMNS_TABLE_NAME));
}
-inolog("#2 %p->table_name=%s(%u)\n", wti, PRINT_NAME(wti->table_name), wti->table_oid);
+MYLOG(1, "#2 %p->table_name=%s(%u)\n", wti, PRINT_NAME(wti->table_name), wti->table_oid);
/*
* Store the table name and the SQLColumns result
* structure
conn->ntables++;
if (res && QR_get_num_cached_tuples(res) > 0)
-inolog("oid item == %s\n", QR_get_value_backend_text(res, 0, 3));
+MYLOG(1, "oid item == %s\n", (const char *) QR_get_value_backend_text(res, 0, 3));
- mylog("Created col_info table='%s', ntables=%d\n", PRINT_NAME(wti->table_name), conn->ntables);
+ MYLOG(0, "Created col_info table='%s', ntables=%d\n", PRINT_NAME(wti->table_name), conn->ntables);
/* Associate a table from the statement with a SQLColumn info */
found = TRUE;
coli->refcnt++;
TABLE_INFO *wti = *pti;
COL_INFO *coli;
-inolog("getCOLIfromTI reloid=%u ti=%p\n", reloid, wti);
+MYLOG(1, "getCOLIfromTI reloid=%u ti=%p\n", reloid, wti);
if (!conn)
conn = SC_get_conn(stmt);
if (!wti) /* SQLColAttribute case */
}
if (!wti)
{
-inolog("before increaseNtab\n");
+MYLOG(1, "before increaseNtab\n");
if (!increaseNtab(stmt, func))
return FALSE;
wti = stmt->ti[stmt->ntab - 1];
}
*pti = wti;
}
-inolog("fi=%p greloid=%d col_info=%p\n", wti, greloid, wti->col_info);
+MYLOG(1, "fi=%p greloid=%d col_info=%p\n", wti, greloid, wti->col_info);
if (0 == greloid)
greloid = wti->table_oid;
if (NULL != wti->col_info)
{
if (conn->col_info[colidx]->table_oid == greloid)
{
- mylog("FOUND col_info table=%ul\n", greloid);
+ MYLOG(0, "FOUND col_info table=%ul\n", greloid);
found = TRUE;
wti->col_info = conn->col_info[colidx];
wti->col_info->refcnt++;
STR_TO_NAME(wti->table_name,
QR_get_value_backend_text(res, 0, COLUMNS_TABLE_NAME));
}
-inolog("#1 %p->table_name=%s(%u)\n", wti, PRINT_NAME(wti->table_name), wti->table_oid);
+MYLOG(1, "#1 %p->table_name=%s(%u)\n", wti, PRINT_NAME(wti->table_name), wti->table_oid);
if (colatt /* SQLColAttribute case */
&& 0 == (wti->flags & TI_COLATTRIBUTE))
{
}
else if (!colatt && stmt)
SC_set_parse_status(stmt, STMT_PARSE_FATAL);
-inolog("getCOLIfromTI returns %d\n", found);
+MYLOG(1, "getCOLIfromTI returns %d\n", found);
return found;
}
BOOL contains_key = FALSE;
int i;
-inolog("%s:fields=%d ntab=%d\n", func, nfields, stmt->ntab);
+MYLOG(1, "%s:fields=" FORMAT_SIZE_T " ntab=%d\n", func, 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)
{
-inolog("%s:key %s found at %p\n", func, keycolnam, fi + i);
+MYLOG(1, "%s:key %s found at %p\n", func, keycolnam, fi + i);
tfi->columnkey = TRUE;
break;
}
}
if (i >= nfields)
{
- mylog("%s: %s not found\n", func, keycolnam);
+ MYLOG(0, "%s: %s not found\n", func, keycolnam);
break;
}
ret = PGAPI_Fetch(pstmt);
goto cleanup;
ret = SQL_SUCCESS;
}
-inolog("%s: contains_key=%d\n", func, contains_key);
+MYLOG(1, "%s: contains_key=%d\n", func, contains_key);
for (i = 0; i < nfields; i++)
{
if (tfi = fi[i], NULL == tfi)
static BOOL include_alias_wo_as(const char *token, const char *btoken)
{
-mylog("alias ? token=%s btoken=%s\n", token, btoken);
+MYLOG(0, "alias ? token=%s btoken=%s\n", token, btoken);
if ('\0' == btoken[0])
return FALSE;
else if (0 == stricmp(")", token))
IRDFields *irdflds;
BOOL updatable = TRUE, column_has_alias = FALSE;
- mylog("%s: entering...\n", func);
+ MYLOG(0, "%s: entering...\n", func);
if (SC_parsed_status(stmt) != STMT_PARSE_NONE)
{
}
else
delimdsp[0] = '\0';
- mylog("unquoted=%d, quote=%d, dquote=%d, numeric=%d, delim='%s', token='%s', ptr='%s'\n", unquoted, quote, dquote, numeric, delimdsp, token, ptr);
+ MYLOG(0, "unquoted=%d, quote=%d, dquote=%d, numeric=%d, delim='%s', token='%s', ptr='%s'\n", unquoted, quote, dquote, numeric, delimdsp, token, ptr);
old_blevel = blevel;
if (unquoted && blevel == 0)
in_distinct = TRUE;
updatable = FALSE;
- mylog("DISTINCT\n");
+ MYLOG(0, "DISTINCT\n");
continue;
}
else if (!stricmp(token, "into"))
{
in_select = FALSE;
- mylog("INTO\n");
+ MYLOG(0, "INTO\n");
stmt->statement_type = STMT_TYPE_CREATE;
SC_set_parse_status(stmt, STMT_PARSE_FATAL);
goto cleanup;
if (stmt->from_pos < 0 &&
(!strnicmp(pptr, "from", 4)))
{
- mylog("First ");
+ MYLOG(0, "First ");
stmt->from_pos = pptr - stmt->statement;
}
- mylog("FROM\n");
+ MYLOG(0, "FROM\n");
continue;
}
} /* in_select && unquoted && blevel == 0 */
if (stmt->where_pos < 0)
stmt->where_pos = pptr - stmt->statement;
- mylog("%s...\n", token);
+ MYLOG(0, "%s...\n", token);
if (stricmp(token, "where") &&
stricmp(token, "order"))
{
if (0 == blevel)
{
in_select = TRUE;
- mylog("SELECT\n");
+ MYLOG(0, "SELECT\n");
continue;
}
else
{
- mylog("SUBSELECT\n");
+ MYLOG(0, "SUBSELECT\n");
if (0 == subqlevel)
subqlevel = blevel;
}
else if (token[0] == '(')
{
blevel++;
- mylog("blevel++ -> %d\n", blevel);
+ MYLOG(0, "blevel++ -> %d\n", blevel);
/* aggregate function ? */
if (stoken[0] && updatable && 0 == subqlevel)
{
else if (token[0] == ')')
{
blevel--;
- mylog("blevel-- = %d\n", blevel);
+ MYLOG(0, "blevel-- = %d\n", blevel);
if (blevel < subqlevel)
subqlevel = 0;
}
}
if (in_select)
{
-mylog("blevel=%d btoken=%s in_dot=%d in_field=%d tbname=%s\n", blevel, btoken, in_dot, in_field, wfi ? SAFE_NAME(wfi->column_alias) : "<null>");
+MYLOG(0, "blevel=%d btoken=%s in_dot=%d in_field=%d tbname=%s\n", blevel, btoken, in_dot, in_field, wfi ? SAFE_NAME(wfi->column_alias) : "<null>");
if (0 == blevel &&
sqlsvr_check &&
dquote &&
if (in_expr || in_func)
{
/* just eat the expression */
- mylog("in_expr=%d or func=%d\n", in_expr, in_func);
+ MYLOG(0, "in_expr=%d or func=%d\n", in_expr, in_func);
if (blevel == 0)
{
if (delim == ',')
{
- mylog("**** Got comma in_expr/func\n");
+ MYLOG(0, "**** Got comma in_expr/func\n");
in_func = FALSE;
in_expr = FALSE;
in_field = FALSE;
}
else if (unquoted && !stricmp(token, "as"))
{
- mylog("got AS in_expr\n");
+ MYLOG(0, "got AS in_expr\n");
in_func = FALSE;
in_expr = FALSE;
in_as = TRUE;
if (in_distinct)
{
- mylog("in distinct\n");
+ MYLOG(0, "in distinct\n");
if (unquoted && !stricmp(token, "on"))
{
in_on = TRUE;
- mylog("got on\n");
+ MYLOG(0, "got on\n");
continue;
}
if (in_on)
in_on = FALSE;
continue; /* just skip the unique on field */
}
- mylog("done distinct\n");
+ MYLOG(0, "done distinct\n");
in_distinct = FALSE;
} /* in_distinct */
/* if (!(irdflds->nfields % FLD_INCR)) */
if (irdflds->nfields >= allocated_size)
{
- mylog("reallocing at nfld=%d\n", irdflds->nfields);
+ MYLOG(0, "reallocing at nfld=%d\n", irdflds->nfields);
new_size = irdflds->nfields + 1;
if (!allocateFields(irdflds, new_size))
{
}
else if (numeric)
{
- mylog("**** got numeric: nfld = %d\n", nfields);
+ MYLOG(0, "**** got numeric: nfld = %d\n", nfields);
if (NULL != wfi)
wfi->numeric = TRUE;
}
else if (0 == old_blevel && blevel > 0)
{ /* expression */
- mylog("got EXPRESSION\n");
+ MYLOG(0, "got EXPRESSION\n");
if (NULL != wfi)
wfi->expr = TRUE;
in_expr = TRUE;
NULL_THE_NAME(wfi->before_dot);
}
if (NULL != wfi)
- mylog("got field='%s', dot='%s'\n", PRINT_NAME(wfi->column_name), PRINT_NAME(wfi->before_dot));
+ MYLOG(0, "got field='%s', dot='%s'\n", PRINT_NAME(wfi->column_name), PRINT_NAME(wfi->before_dot));
if (delim == ',')
- mylog("comma (1)\n");
+ MYLOG(0, "comma (1)\n");
else
in_field = TRUE;
nfields++;
if (delim == ',')
{
- mylog("in_dot: got comma\n");
+ MYLOG(0, "in_dot: got comma\n");
in_field = FALSE;
}
in_dot = FALSE;
if (NULL != wfi)
{
STRX_TO_NAME(wfi->column_alias, token);
- mylog("alias for field '%s' is '%s'\n", PRINT_NAME(wfi->column_name), PRINT_NAME(wfi->column_alias));
+ MYLOG(0, "alias for field '%s' is '%s'\n", PRINT_NAME(wfi->column_name), PRINT_NAME(wfi->column_alias));
}
in_as = FALSE;
in_field = FALSE;
if (delim == ',')
- mylog("comma(2)\n");
+ MYLOG(0, "comma(2)\n");
continue;
}
* name will have the function name -- maybe useful some
* day
*/
- mylog("**** got function = '%s'\n", PRINT_NAME(wfi->column_name));
+ MYLOG(0, "**** got function = '%s'\n", PRINT_NAME(wfi->column_name));
}
continue;
}
if (token[0] == '.')
{
in_dot = TRUE;
- mylog("got dot\n");
+ MYLOG(0, "got dot\n");
continue;
}
if (!stricmp(token, "as"))
{
in_as = TRUE;
- mylog("got AS\n");
+ MYLOG(0, "got AS\n");
continue;
}
NULL_THE_NAME(wfi->column_name);
wfi->column_size = 0;
}
- mylog("*** setting expression\n");
+ MYLOG(0, "*** setting expression\n");
}
else
- mylog("*** may be an alias for a field\n");
+ MYLOG(0, "*** may be an alias for a field\n");
if (0 == blevel && ',' == delim)
{
in_expr = in_func = in_field = FALSE;
;
else if (0 == stricmp(token, "select"))
{
- mylog("got subquery lvl=%d\n", blevel);
+ MYLOG(0, "got subquery lvl=%d\n", blevel);
is_table_name = FALSE;
is_subquery = TRUE;
}
else if ('(' == ptr[0])
{
- mylog("got srf? = '%s'\n", token);
+ MYLOG(0, "got srf? = '%s'\n", token);
is_table_name = FALSE;
}
if (NULL != wti)
{
STRX_TO_NAME(wti->table_name, token);
lower_the_name(GET_NAME(wti->table_name), conn, dquote);
- mylog("got table = '%s'\n", PRINT_NAME(wti->table_name));
+ MYLOG(0, "got table = '%s'\n", PRINT_NAME(wti->table_name));
}
else
{
if (0 == blevel && delim == ',')
{
out_table = TRUE;
- mylog("more than 1 tables\n");
+ MYLOG(0, "more than 1 tables\n");
}
else
{
if (NULL != wti)
{
STRX_TO_NAME(wti->table_alias, token);
- mylog("alias for table '%s' is '%s'\n", PRINT_NAME(wti->table_name), PRINT_NAME(wti->table_alias));
+ MYLOG(0, "alias for table '%s' is '%s'\n", PRINT_NAME(wti->table_name), PRINT_NAME(wti->table_alias));
}
in_table = FALSE;
if (delim == ',')
{
out_table = TRUE;
- mylog("more than 1 tables\n");
+ MYLOG(0, "more than 1 tables\n");
}
}
}
wfi->ti = ti[0];
}
- mylog("--------------------------------------------\n");
- mylog("nfld=%d, ntab=%d\n", irdflds->nfields, stmt->ntab);
+ MYLOG(0, "--------------------------------------------\n");
+ MYLOG(0, "nfld=%d, ntab=%d\n", irdflds->nfields, stmt->ntab);
if (0 == stmt->ntab)
{
SC_set_parse_status(stmt, STMT_PARSE_FATAL);
for (i = 0; i < (int) irdflds->nfields; i++)
{
wfi = fi[i];
- mylog("Field %d: expr=%d, func=%d, quote=%d, dquote=%d, numeric=%d, name='%s', alias='%s', dot='%s'\n", i, wfi->expr, wfi->func, wfi->quote, wfi->dquote, wfi->numeric, PRINT_NAME(wfi->column_name), PRINT_NAME(wfi->column_alias), PRINT_NAME(wfi->before_dot));
+ MYLOG(0, "Field %d: expr=%d, func=%d, quote=%d, dquote=%d, numeric=%d, name='%s', alias='%s', dot='%s'\n", i, wfi->expr, wfi->func, wfi->quote, wfi->dquote, wfi->numeric, PRINT_NAME(wfi->column_name), PRINT_NAME(wfi->column_alias), PRINT_NAME(wfi->before_dot));
if (wfi->ti)
- mylog(" ----> table_name='%s', table_alias='%s'\n", PRINT_NAME(wfi->ti->table_name), PRINT_NAME(wfi->ti->table_alias));
+ MYLOG(0, " ----> table_name='%s', table_alias='%s'\n", PRINT_NAME(wfi->ti->table_name), PRINT_NAME(wfi->ti->table_alias));
}
for (i = 0; i < stmt->ntab; i++)
{
wti = ti[i];
- mylog("Table %d: name='%s', alias='%s'\n", i, PRINT_NAME(wti->table_name), PRINT_NAME(wti->table_alias));
+ MYLOG(0, "Table %d: name='%s', alias='%s'\n", i, PRINT_NAME(wti->table_name), PRINT_NAME(wti->table_alias));
}
/*
goto cleanup;
}
- mylog("Done PG_Columns\n");
+ MYLOG(0, "Done PG_Columns\n");
/*
* Now resolve the fields to point to column info
cols,
increased_cols;
- mylog("expanding field %d\n", i);
+ MYLOG(0, "expanding field %d\n", i);
total_cols = 0;
/* Allocate some more field pointers if necessary */
new_size = irdflds->nfields + increased_cols;
- mylog("k=%d, increased_cols=%d, allocated_size=%d, new_size=%d\n", k, increased_cols, allocated_size, new_size);
+ MYLOG(0, "k=%d, increased_cols=%d, allocated_size=%d, new_size=%d\n", k, increased_cols, allocated_size, new_size);
if (new_size > allocated_size)
{
int new_alloc = new_size;
- mylog("need more cols: new_alloc = %d\n", new_alloc);
+ MYLOG(0, "need more cols: new_alloc = %d\n", new_alloc);
if (!allocateFields(irdflds, new_alloc))
{
SC_set_parse_status(stmt, STMT_PARSE_FATAL);
*/
for (j = irdflds->nfields - 1; j > i; j--)
{
- mylog("copying field %d to %d\n", j, increased_cols + j);
+ MYLOG(0, "copying field %d to %d\n", j, increased_cols + j);
fi[increased_cols + j] = fi[j];
}
- mylog("done copying fields\n");
+ MYLOG(0, "done copying fields\n");
/* Set the new number of fields */
irdflds->nfields += increased_cols;
- mylog("irdflds->nfields now at %d\n", irdflds->nfields);
+ MYLOG(0, "irdflds->nfields now at %d\n", irdflds->nfields);
/* copy the new field info */
FIELD_INFO *afi;
BOOL reuse = TRUE;
- mylog("creating field info: n=%d\n", n);
+ MYLOG(0, "creating field info: n=%d\n", n);
/* skip malloc (already did it for the Star) */
if (k > 0 || n > 0)
{
- mylog("allocating field info at %d\n", n + i);
+ MYLOG(0, "allocating field info at %d\n", n + i);
fi[n + i] = (FIELD_INFO *) malloc(sizeof(FIELD_INFO));
if (fi[n + i] == NULL)
{
FI_Constructor(afi, reuse);
afi->ti = the_ti;
- mylog("about to copy at %d\n", n + i);
+ MYLOG(0, "about to copy at %d\n", n + i);
getColInfo(the_ti->col_info, afi, n);
afi->updatable = updatable;
- mylog("done copying\n");
+ MYLOG(0, "done copying\n");
}
i += cols;
- mylog("i now at %d\n", i);
+ MYLOG(0, "i now at %d\n", i);
}
}
parse = FALSE;
}
- mylog("done %s: parse=%d, parse_status=%d\n", func, parse, SC_parsed_status(stmt));
+ MYLOG(0, "done %s: parse=%d, parse_status=%d\n", func, parse, SC_parsed_status(stmt));
return parse;
}
RETCODE ret;
CSTR func = "PGAPI_GetDiagRec";
- mylog("%s entering type=%d rec=%d\n", func, HandleType, RecNumber);
+ MYLOG(0, "%s entering type=%d rec=%d\n", func, HandleType, RecNumber);
switch (HandleType)
{
case SQL_HANDLE_ENV:
default:
ret = SQL_ERROR;
}
- mylog("%s exiting %d\n", func, ret);
+ MYLOG(0, "%s exiting %d\n", func, ret);
return ret;
}
int rtnctype = SQL_C_CHAR;
CSTR func = "PGAPI_GetDiagField";
- mylog("%s entering rec=%d", func, RecNumber);
+ MYLOG(0, "%s entering rec=%d", func, RecNumber);
switch (HandleType)
{
case SQL_HANDLE_ENV:
rc = QR_get_num_total_tuples(res) - res->dl_count;
}
*((SQLLEN *) DiagInfoPtr) = rc;
-inolog("rc=%d\n", rc);
+MYLOG(1, "rc=" FORMAT_LEN "\n", rc);
ret = SQL_SUCCESS;
break;
case SQL_DIAG_ROW_COUNT:
if (StringLengthPtr)
*StringLengthPtr = (SQLSMALLINT) rtnlen;
}
- mylog("%s exiting %d\n", func, ret);
+ MYLOG(0, "%s exiting %d\n", func, ret);
return ret;
}
RETCODE ret = SQL_SUCCESS;
SQLINTEGER len = 4;
- mylog("PGAPI_GetConnectAttr %d\n", Attribute);
+ MYLOG(0, "PGAPI_GetConnectAttr %d\n", Attribute);
switch (Attribute)
{
case SQL_ATTR_ASYNC_ENABLE:
}
if (RecNumber <=0)
{
-inolog("%s RecN=%d allocated=%d\n", func, RecNumber, opts->allocated);
+MYLOG(1, "%s RecN=%d allocated=%d\n", func, RecNumber, opts->allocated);
DC_set_error(desc, DESC_BAD_PARAMETER_NUMBER_ERROR,
"bad parameter number");
return SQL_ERROR;
}
if (RecNumber > opts->allocated)
{
-inolog("%s RecN=%d allocated=%d\n", func, RecNumber, opts->allocated);
+MYLOG(1, "%s RecN=%d allocated=%d\n", func, 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)
{
-inolog("IPDSetField RecN=%d allocated=%d\n", RecNumber, ipdopts->allocated);
+MYLOG(1, "IPDSetField 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)
{
-inolog("APDGetField RecN=%d allocated=%d\n", RecNumber, opts->allocated);
+MYLOG(1, "APDGetField 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)
{
-inolog("IPDGetField RecN=%d allocated=%d\n", RecNumber, ipdopts->allocated);
+MYLOG(1, "IPDGetField 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("%s Handle=%p %d\n", func, StatementHandle, Attribute);
+ MYLOG(0, "%s Handle=%p %d\n", func, StatementHandle, Attribute);
switch (Attribute)
{
case SQL_ATTR_FETCH_BOOKMARK_PTR: /* 16 */
BOOL unsupported = FALSE;
int newValue;
- mylog("%s for %p: %d %p\n", func, ConnectionHandle, Attribute, Value);
+ MYLOG(0, "%s for %p: %d %p\n", func, ConnectionHandle, Attribute, Value);
switch (Attribute)
{
case SQL_ATTR_METADATA_ID:
case SQL_ATTR_ANSI_APP:
if (SQL_AA_FALSE != CAST_PTR(SQLINTEGER, Value))
{
- mylog("the application is ansi\n");
+ MYLOG(0, "the application is ansi\n");
if (CC_is_in_unicode_driver(conn)) /* the driver is unicode */
CC_set_in_ansi_app(conn); /* but the app is ansi */
}
else
{
- mylog("the application is unicode\n");
+ MYLOG(0, "the application is unicode\n");
}
/*return SQL_ERROR;*/
return SQL_SUCCESS;
case SQL_ATTR_ENLIST_IN_DTC:
#ifdef WIN32
#ifdef _HANDLE_ENLIST_IN_DTC_
- mylog("SQL_ATTR_ENLIST_IN_DTC %p request received\n", Value);
+ MYLOG(0, "SQL_ATTR_ENLIST_IN_DTC %p request received\n", Value);
if (conn->connInfo.xa_opt != 0)
{
/*
logs_on_off(-1, conn->connInfo.drivers.debug, 0);
conn->connInfo.drivers.debug = newValue;
logs_on_off(1, conn->connInfo.drivers.debug, 0);
- mylog("debug => %d\n", conn->connInfo.drivers.debug);
+ MYLOG(0, "debug => %d\n", conn->connInfo.drivers.debug);
}
else if (newValue == 0 && conn->connInfo.drivers.debug > 0)
{
- mylog("debug => %d\n", newValue);
+ MYLOG(0, "debug => %d\n", newValue);
logs_on_off(-1, conn->connInfo.drivers.debug, 0);
conn->connInfo.drivers.debug = newValue;
logs_on_off(1, 0, 0);
conn->connInfo.drivers.debug = newValue;
logs_on_off(1, 0, 0);
}
- mylog("commlog => %d\n", conn->connInfo.drivers.commlog);
+ MYLOG(0, "commlog => %d\n", conn->connInfo.drivers.commlog);
break;
case SQL_ATTR_PGOPT_PARSE:
conn->connInfo.drivers.parse = CAST_UPTR(SQLCHAR, Value);
qlog("parse => %d\n", conn->connInfo.drivers.parse);
- mylog("parse => %d\n", conn->connInfo.drivers.parse);
+ MYLOG(0, "parse => %d\n", conn->connInfo.drivers.parse);
break;
case SQL_ATTR_PGOPT_USE_DECLAREFETCH:
conn->connInfo.drivers.use_declarefetch = CAST_UPTR(SQLCHAR, Value);
ci_updatable_cursors_set(&conn->connInfo);
qlog("declarefetch => %d\n", conn->connInfo.drivers.use_declarefetch);
- mylog("declarefetch => %d\n", conn->connInfo.drivers.use_declarefetch);
+ MYLOG(0, "declarefetch => %d\n", conn->connInfo.drivers.use_declarefetch);
break;
case SQL_ATTR_PGOPT_SERVER_SIDE_PREPARE:
conn->connInfo.use_server_side_prepare = CAST_UPTR(SQLCHAR, Value);
qlog("server_side_prepare => %d\n", conn->connInfo.use_server_side_prepare);
- mylog("server_side_prepare => %d\n", conn->connInfo.use_server_side_prepare);
+ MYLOG(0, "server_side_prepare => %d\n", conn->connInfo.use_server_side_prepare);
break;
case SQL_ATTR_PGOPT_FETCH:
conn->connInfo.drivers.fetch_max = CAST_PTR(SQLINTEGER, Value);
qlog("fetch => %d\n", conn->connInfo.drivers.fetch_max);
- mylog("fetch => %d\n", conn->connInfo.drivers.fetch_max);
+ MYLOG(0, "fetch => %d\n", conn->connInfo.drivers.fetch_max);
break;
case SQL_ATTR_PGOPT_UNKNOWNSIZES:
conn->connInfo.drivers.unknown_sizes = CAST_PTR(SQLINTEGER, Value);
qlog("unknown_sizes => %d\n", conn->connInfo.drivers.unknown_sizes);
- mylog("unknown_sizes => %d\n", conn->connInfo.drivers.unknown_sizes);
+ MYLOG(0, "unknown_sizes => %d\n", conn->connInfo.drivers.unknown_sizes);
break;
case SQL_ATTR_PGOPT_TEXTASLONGVARCHAR:
conn->connInfo.drivers.text_as_longvarchar = CAST_PTR(SQLINTEGER, Value);
qlog("text_as_longvarchar => %d\n", conn->connInfo.drivers.text_as_longvarchar);
- mylog("text_as_longvarchar => %d\n", conn->connInfo.drivers.text_as_longvarchar);
+ MYLOG(0, "text_as_longvarchar => %d\n", conn->connInfo.drivers.text_as_longvarchar);
break;
case SQL_ATTR_PGOPT_UNKNOWNSASLONGVARCHAR:
conn->connInfo.drivers.unknowns_as_longvarchar = CAST_PTR(SQLINTEGER, Value);
qlog("unknowns_as_long_varchar => %d\n", conn->connInfo.drivers.unknowns_as_longvarchar);
- mylog("unknowns_as_long_varchar => %d\n", conn->connInfo.drivers.unknowns_as_longvarchar);
+ MYLOG(0, "unknowns_as_long_varchar => %d\n", conn->connInfo.drivers.unknowns_as_longvarchar);
break;
case SQL_ATTR_PGOPT_BOOLSASCHAR:
conn->connInfo.drivers.bools_as_char = CAST_PTR(SQLINTEGER, Value);
qlog("bools_as_char => %d\n", conn->connInfo.drivers.bools_as_char);
- mylog("bools_as_char => %d\n", conn->connInfo.drivers.bools_as_char);
+ MYLOG(0, "bools_as_char => %d\n", conn->connInfo.drivers.bools_as_char);
break;
case SQL_ATTR_PGOPT_MAXVARCHARSIZE:
conn->connInfo.drivers.max_varchar_size = CAST_PTR(SQLINTEGER, Value);
qlog("max_varchar_size => %d\n", conn->connInfo.drivers.max_varchar_size);
- mylog("max_varchar_size => %d\n", conn->connInfo.drivers.max_varchar_size);
+ MYLOG(0, "max_varchar_size => %d\n", conn->connInfo.drivers.max_varchar_size);
break;
case SQL_ATTR_PGOPT_MAXLONGVARCHARSIZE:
conn->connInfo.drivers.max_longvarchar_size = CAST_PTR(SQLINTEGER, Value);
qlog("max_longvarchar_size => %d\n", conn->connInfo.drivers.max_longvarchar_size);
- mylog("max_longvarchar_size => %d\n", conn->connInfo.drivers.max_longvarchar_size);
+ MYLOG(0, "max_longvarchar_size => %d\n", conn->connInfo.drivers.max_longvarchar_size);
break;
case SQL_ATTR_PGOPT_WCSDEBUG:
conn->connInfo.wcs_debug = CAST_PTR(SQLINTEGER, Value);
qlog("wcs_debug => %d\n", conn->connInfo.wcs_debug);
- mylog("wcs_debug => %d\n", conn->connInfo.wcs_debug);
+ MYLOG(0, "wcs_debug => %d\n", conn->connInfo.wcs_debug);
break;
default:
if (Attribute < 65536)
RETCODE ret = SQL_SUCCESS;
DescriptorClass *desc = (DescriptorClass *) DescriptorHandle;
- mylog("%s h=%p rec=%d field=%d blen=%d\n", func, DescriptorHandle, RecNumber, FieldIdentifier, BufferLength);
+ MYLOG(0, "%s h=%p rec=%d field=%d blen=%d\n", func, 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("%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, "%s h=%p(%d) rec=%d field=%d val=%p,%d\n", func, 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("%s Handle=%p %d,%u(%p)\n", func, StatementHandle, Attribute, Value, Value);
+ MYLOG(0, "%s Handle=%p %d," FORMAT_ULEN "(%p)\n", func, StatementHandle, Attribute, (SQLULEN) Value, Value);
switch (Attribute)
{
case SQL_ATTR_ENABLE_AUTO_IPD: /* 15 */
else
{
stmt->ard = (DescriptorClass *) Value;
-inolog("set ard=%p\n", stmt->ard);
+MYLOG(1, "set ard=%p\n", stmt->ard);
}
break;
case SQL_ATTR_APP_PARAM_DESC: /* 10011 */
if (s->need_data_callback)
{
- mylog("bulk_ope_callback in\n");
+ MYLOG(0, "bulk_ope_callback in\n");
s->processed++;
s->idx++;
}
ConnectionClass *conn;
BindInfoClass *bookmark;
- mylog("%s operation = %d\n", func, operationX);
+ MYLOG(0, "%s operation = %d\n", func, operationX);
s.stmt = (StatementClass *) hstmt;
s.operation = operationX;
SC_clear_error(s.stmt);
static SQLSMALLINT
get_interval_type(Int4 atttypmod, const char **name)
{
-mylog("!!! %s atttypmod=%x\n", __FUNCTION__, atttypmod);
+MYLOG(0, "!!! %s atttypmod=%x\n", __FUNCTION__, atttypmod);
if ((-1) == atttypmod)
return 0;
if (0 != (YEAR_BIT & atttypmod))
int p = -1, maxsize;
const ConnInfo *ci = &(conn->connInfo);
- mylog("%s: type=%d, atttypmod=%d, adtsize_or=%d, unknown = %d\n", __FUNCTION__, type, atttypmod, adtsize_or_longestlen, handle_unknown_size_as);
+ MYLOG(0, "%s: type=%d, atttypmod=%d, adtsize_or=%d, unknown = %d\n", __FUNCTION__, type, atttypmod, adtsize_or_longestlen, handle_unknown_size_as);
/* Assign Maximum size based on parameters */
switch (type)
* Static ColumnSize (i.e., the Maximum ColumnSize of the datatype) This
* has nothing to do with a result set.
*/
-inolog("!!! atttypmod < 0 ?\n");
+MYLOG(1, "!!! atttypmod < 0 ?\n");
if (atttypmod < 0 && adtsize_or_longestlen < 0)
return maxsize;
-inolog("!!! adtsize_or_logngest=%d\n", adtsize_or_longestlen);
+MYLOG(1, "!!! adtsize_or_logngest=%d\n", adtsize_or_longestlen);
p = adtsize_or_longestlen; /* longest */
/*
* Catalog Result Sets -- use assigned column width (i.e., from
* set_tuplefield_string)
*/
-inolog("!!! catalog_result=%d\n", handle_unknown_size_as);
+MYLOG(1, "!!! catalog_result=%d\n", handle_unknown_size_as);
if (UNKNOWNS_AS_LONGEST == handle_unknown_size_as)
{
- mylog("%s: LONGEST: p = %d\n", __FUNCTION__, p);
+ MYLOG(0, "%s: LONGEST: p = %d\n", __FUNCTION__, p);
if (p > 0 &&
(atttypmod < 0 || atttypmod > p))
return p;
{
Int4 default_decimal_digits = 6;
- mylog("%s: type=%d, atttypmod=%d\n", __FUNCTION__, type, atttypmod);
+ MYLOG(0, "%s: type=%d, atttypmod=%d\n", __FUNCTION__, type, atttypmod);
if (atttypmod < 0 && adtsize_or_longest < 0)
return default_decimal_digits;
{
Int4 default_column_size = 28;
- mylog("%s: type=%d, typmod=%d\n", __FUNCTION__, type, atttypmod);
+ MYLOG(0, "%s: type=%d, typmod=%d\n", __FUNCTION__, type, atttypmod);
if (atttypmod > -1)
return (atttypmod >> 16) & 0xffff;
static SQLSMALLINT
getTimestampDecimalDigitsX(const ConnectionClass *conn, OID type, int atttypmod)
{
- mylog("%s: type=%d, atttypmod=%d\n", __FUNCTION__, type, atttypmod);
+ MYLOG(0, "%s: type=%d, atttypmod=%d\n", __FUNCTION__, type, atttypmod);
return (atttypmod > -1 ? atttypmod : 6);
}
{
Int4 fixed, scale;
- mylog("%s: type=%d, atttypmod=%d\n", __FUNCTION__, type, atttypmod);
+ MYLOG(0, "%s: type=%d, atttypmod=%d\n", __FUNCTION__, type, atttypmod);
switch (type)
{
{
Int4 prec;
- mylog("%s: type=%d, atttypmod=%d\n", __FUNCTION__, type, atttypmod);
+ MYLOG(0, "%s: type=%d, atttypmod=%d\n", __FUNCTION__, type, atttypmod);
if ((atttypmod & SECOND_BIT) == 0)
return 0;
{
Int4 ttl, leading_precision = 9, scale;
- mylog("%s: type=%d, atttypmod=%d\n", __FUNCTION__, type, atttypmod);
+ MYLOG(0, "%s: type=%d, atttypmod=%d\n", __FUNCTION__, type, atttypmod);
ttl = leading_precision;
switch (get_interval_type(atttypmod, NULL))
case PG_TYPE_XID:
return "xid";
case PG_TYPE_INT4:
-inolog("pgtype_to_name int4\n");
+MYLOG(1, "pgtype_to_name int4\n");
return auto_increment ? "serial" : "int4";
case PG_TYPE_FLOAT4:
return "float4";
else if (strnicmp(fname, "sqlservr", 8) == 0)
exepgm = 3;
}
- mylog("exe name=%s\n", fname);
+ MYLOG(0, "exe name=%s\n", fname);
}
break;
break;
case DLL_PROCESS_DETACH:
- mylog("DETACHING %s\n", DRIVER_FILE_NAME);
+ MYLOG(0, "DETACHING %s\n", DRIVER_FILE_NAME);
CleanupDelayLoadedDLLs();
/* my(q)log is unavailable from here */
finalize_global_cs();
#ifdef _WIN64
#define FORMAT_LEN "%I64d" /* SQLLEN */
#define FORMAT_ULEN "%I64u" /* SQLULEN */
+#define FORMAT_POSIROW "%I64u"
#else /* _WIN64 */
#define FORMAT_LEN "%ld" /* SQLLEN */
#define FORMAT_ULEN "%lu" /* SQLULEN */
+#define FORMAT_POSIROW "%hu"
#endif /* _WIN64 */
#else /* WIN32 */
#define FORMAT_SIZE_T "%zu" /* size_t */
#define FORMAT_ULEN "%lu" /* SQLULEN */
#endif /* HAVE_LONG_LONG */
#endif /* SIZEOF_LONG */
+
+#if (SIZEOF_VOID_P == 8) && !defined(WITH_IODBC)
+#define FORMAT_POSIROW FORMAT_ULEN
+#else
+#define FORMAT_POSIROW "%u"
+#endif
+
#endif /* WIN32 */
+
#define CAST_PTR(type, ptr) (type)((LONG_PTR)(ptr))
#define CAST_UPTR(type, ptr) (type)((ULONG_PTR)(ptr))
#ifndef SQL_IS_LEN
; // getCommonDefaults(DBMS_NAME, ODBCINST_INI, NULL);
#ifdef PG_BIN
if (s_hLModule = LoadLibraryEx(PG_BIN "\\libpq.dll", NULL, LOAD_WITH_ALTERED_SEARCH_PATH), s_hLModule == NULL)
- mylog("libpq in the folder %s couldn't be loaded\n", PG_BIN);
+ MYLOG(0, "libpq in the folder %s couldn't be loaded\n", PG_BIN);
#endif /* PG_BIN */
if (NULL == s_hLModule)
{
SPRINTF_FIXED(dllPath, "%s%slibpq.dll", drive, dir);
if (s_hLModule = LoadLibraryEx(dllPath, NULL, LOAD_WITH_ALTERED_SEARCH_PATH), s_hLModule == NULL)
{
- mylog("libpq in the folder %s%s couldn't be loaded\n", drive, dir);
+ MYLOG(0, "libpq in the folder %s%s couldn't be loaded\n", drive, dir);
SPRINTF_FIXED(message, "libpq in neither %s nor %s%s could be loaded", PG_BIN, drive, dir);
}
}
break;
case DLL_PROCESS_DETACH:
- mylog("DETACHING psqlsetup\n");
+ MYLOG(0, "DETACHING psqlsetup\n");
CleanupDelayLoadedDLLs();
if (NULL != s_hLModule)
{
- mylog("Freeing Library libpq\n");
+ MYLOG(0, "Freeing Library libpq\n");
FreeLibrary(s_hLModule);
}
if (NULL != s_hLModule2)
{
- mylog("Freeing Library %s\n", psqlodbc);
+ MYLOG(0, "Freeing Library %s\n", psqlodbc);
FreeLibrary(s_hLModule2);
}
finalize_global_cs();
QR_set_num_fields(QResultClass *self, int new_num_fields)
{
if (!self) return;
- mylog("in QR_set_num_fields\n");
+ MYLOG(0, "in QR_set_num_fields\n");
CI_set_num_fields(QR_get_fields(self), new_num_fields);
- mylog("exit QR_set_num_fields\n");
+ MYLOG(0, "exit QR_set_num_fields\n");
}
QR_inc_rowstart_in_cache(QResultClass *self, SQLLEN base_inc)
{
if (!QR_has_valid_base(self))
- mylog("QR_inc_rowstart_in_cache called while the cache is not ready\n");
+ MYLOG(0, "QR_inc_rowstart_in_cache 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("in QR_Constructor\n");
+ MYLOG(0, "in QR_Constructor\n");
rv = (QResultClass *) malloc(sizeof(QResultClass));
if (rv != NULL)
rv->deleted_keyset = NULL;
}
- mylog("exit QR_Constructor\n");
+ MYLOG(0, "exit QR_Constructor\n");
return rv;
}
BOOL top = TRUE;
if (!self) return;
- mylog("QResult: in QR_close_result\n");
+ MYLOG(0, "QResult: in QR_close_result\n");
while(self)
{
top = FALSE;
}
- mylog("QResult: exit close_result\n");
+ MYLOG(0, "QResult: exit close_result\n");
}
void
QR_reset_for_re_execute(QResultClass *self)
{
- mylog("QResult: enter %s for %x\n", __FUNCTION__, self);
+ MYLOG(0, "QResult: enter %s for %p\n", __FUNCTION__, self);
if (!self) return;
QR_close_result(self, FALSE);
/* reset flags etc */
self->sqlstate[0] = '\0';
self->messageref = NULL;
- mylog("QResult: exit %s\n", __FUNCTION__);
+ MYLOG(0, "QResult: exit %s\n", __FUNCTION__);
}
void
QR_Destructor(QResultClass *self)
{
- mylog("QResult: enter DESTRUCTOR\n");
+ MYLOG(0, "QResult: enter DESTRUCTOR\n");
if (!self) return;
QR_close_result(self, TRUE);
- mylog("QResult: exit DESTRUCTOR\n");
+ MYLOG(0, "QResult: exit DESTRUCTOR\n");
}
UInt4 num_fields;
if (!self) return NULL;
-inolog("QR_AddNew %dth row(%d fields) alloc=%d\n", self->num_cached_rows, QR_NumResultCols(self), self->count_backend_allocated);
+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);
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("QResult: free memory in, fcount=%d\n", num_backend_rows);
+ MYLOG(0, "QResult: free memory in, fcount=" FORMAT_LEN "\n", num_backend_rows);
if (self->backend_tuples)
{
self->cursTuple = -1;
self->pstatus = 0;
- mylog("QResult: free memory out\n");
+ MYLOG(0, "QResult: free memory out\n");
}
/* at first read in the number of fields that are in the query */
new_num_fields = PQnfields(*pgres);
- mylog("num_fields = %d\n", new_num_fields);
+ MYLOG(0, "num_fields = %d\n", new_num_fields);
/* according to that allocate memory */
QR_set_num_fields(self, new_num_fields);
if (new_atttypmod < 0)
new_atttypmod = -1;
- mylog("%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, "%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);
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)
{
-inolog("!![%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++;
}
if (!QR_read_tuples_from_pgres(self, pgres))
return FALSE;
-inolog("!!%p->cursTup=%d total_read=%d\n", self, self->cursTuple, self->num_total_read);
+MYLOG(1, "!!%p->cursTup=" FORMAT_LEN " total_read=" FORMAT_ULEN "\n", self, self->cursTuple, self->num_total_read);
if (!QR_once_reached_eof(self) && self->cursTuple >= (Int4) self->num_total_read)
self->num_total_read = self->cursTuple + 1;
/* EOF is 'fetched < fetch requested' */
if (self->num_cached_rows - num_cached_rows < self->cmd_fetch_size)
{
- mylog("detect EOF %d - %d < %d\n", self->num_cached_rows, num_cached_rows, self->cmd_fetch_size);
+ MYLOG(0, "detect EOF " FORMAT_ULEN " - %d < " FORMAT_ULEN "\n", self->num_cached_rows, num_cached_rows, self->cmd_fetch_size);
reached_eof_now = TRUE;
QR_set_reached_eof(self);
}
if (NULL != conn)
{
/* Force a read to occur in next_tuple */
- QR_set_next_in_cache(self, 0);
+ QR_set_next_in_cache(self, (SQLLEN) 0);
QR_set_rowstart_in_cache(self, 0);
self->key_base = 0;
}
else
{
BOOL does_commit = FALSE;
- UDWORD flag = 0;
+ unsigned int flag = 0;
char buf[64];
flag = READ_ONLY_QUERY;
CC_does_autocommit(conn) &&
CC_cursor_count(conn) <= 1)
{
- mylog("QResult: END transaction on conn=%p\n", conn);
+ MYLOG(0, "QResult: END transaction on conn=%p\n", conn);
if ((ROLLBACK_ON_ERROR & flag) == 0)
{
STRCAT_FIXED(buf, ";commit");
does_commit = TRUE;
}
-inolog(" !!!! %s:Case I CC_send_query %s flag=%x\n", __FUNCTION__, buf, flag);
+MYLOG(1, " !!!! %s:Case I CC_send_query %s flag=%x\n", __FUNCTION__, 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("QResult: END transaction on conn=%p\n", conn);
+ MYLOG(0, "QResult: 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);
-inolog("QR_get_tupledata %p->num_fields=%d\n", self, self->num_fields);
+MYLOG(1, "QR_get_tupledata %p->num_fields=%d\n", self, self->num_fields);
if (!QR_get_cursor(self))
{
{
SQLLEN tuple_size = self->count_backend_allocated;
- mylog("REALLOC: old_count = %d, size = %d\n", tuple_size, self->num_fields * sizeof(TupleField) * tuple_size);
+ MYLOG(0, "REALLOC: old_count = " FORMAT_LEN ", size = " FORMAT_SIZE_T "\n", tuple_size, self->num_fields * sizeof(TupleField) * tuple_size);
if (tuple_size < 1)
tuple_size = TUPLE_MALLOC_INC;
else
ConnInfo *ci;
BOOL reached_eof_now = FALSE, curr_eof; /* detecting EOF is pretty important */
-inolog("Oh %p->fetch_number=%d\n", self, self->fetch_number);
-inolog("in total_read=%d cursT=%d currT=%d ad=%d total=%d rowsetSize=%d\n", self->num_total_read, self->cursTuple, stmt->currTuple, self->ad_count, QR_get_num_total_tuples(self), self->rowset_size_include_ommitted);
+MYLOG(1, "Oh %p->fetch_number=" FORMAT_LEN "\n", self, self->fetch_number);
+MYLOG(1, "in total_read=" FORMAT_ULEN " cursT=" FORMAT_LEN " currT=" FORMAT_LEN " ad=%d total=" FORMAT_ULEN " rowsetSize=%d\n", self->num_total_read, self->cursTuple, stmt->currTuple, self->ad_count, QR_get_num_total_tuples(self), self->rowset_size_include_ommitted);
num_total_rows = QR_get_num_total_tuples(self);
conn = QR_get_conn(self);
}
else
self->cache_size = req_size;
-inolog("cache=%d rowset=%d movement=" FORMAT_ULEN "\n", self->cache_size, req_size, movement);
+MYLOG(1, "cache=" FORMAT_ULEN " rowset=%d movement=" FORMAT_ULEN "\n", self->cache_size, req_size, movement);
SPRINTF_FIXED(movecmd,
"move backward " FORMAT_ULEN " in \"%s\"",
movement, QR_get_cursor(self));
moved = movement;
if (sscanf(mres->command, "MOVE " FORMAT_ULEN, &moved) > 0)
{
-inolog("moved=%d ? " FORMAT_ULEN "\n", moved, movement);
+MYLOG(1, "moved=" FORMAT_ULEN " ? " FORMAT_ULEN "\n", moved, movement);
if (moved < movement)
{
if (0 < moved)
RETURN(-1)
}
/* return a row from cache */
- mylog("%s: fetch_number < fcount: returning tuple %d, fcount = %d\n", func, fetch_number, num_backend_rows);
+ MYLOG(0, "%s: fetch_number < fcount: returning tuple " FORMAT_LEN ", fcount = " FORMAT_LEN "\n", func, fetch_number, num_backend_rows);
self->tupleField = the_tuples + (fetch_number * num_fields);
-inolog("tupleField=%p\n", self->tupleField);
+MYLOG(1, "tupleField=%p\n", self->tupleField);
/* move to next row */
QR_inc_next_in_cache(self);
RETURN(TRUE)
reached_eod = TRUE;
if (reached_eod)
{
- mylog("next_tuple: fetch end\n");
+ MYLOG(0, "next_tuple: fetch end\n");
self->tupleField = NULL;
/* end of tuples */
RETURN(-1)
if (!QR_get_cursor(self))
{
- mylog("%s: ALL_ROWS: done, fcount = %d, fetch_number = %d\n", func, QR_get_num_total_tuples(self), fetch_number);
+ MYLOG(0, "%s: ALL_ROWS: done, fcount = " FORMAT_ULEN ", fetch_number = " FORMAT_LEN "\n", func, QR_get_num_total_tuples(self), fetch_number);
self->tupleField = NULL;
QR_set_reached_eof(self);
RETURN(-1) /* end of tuples */
/* not a correction */
self->cache_size = fetch_size;
/* clear obsolete tuples */
-inolog("clear obsolete %d tuples\n", num_backend_rows);
+MYLOG(1, "clear obsolete " FORMAT_LEN " tuples\n", num_backend_rows);
ClearCachedRows(tuple, num_fields, num_backend_rows);
self->dataFilled = FALSE;
QR_stop_movement(self);
fetch_size = (Int4) (end_tuple - num_backend_rows);
if (fetch_size <= 0)
{
- mylog("corrupted fetch_size end_tuple=%d <= cached_rows=%d\n", end_tuple, num_backend_rows);
+ MYLOG(0, "corrupted fetch_size end_tuple=" FORMAT_LEN " <= cached_rows=" FORMAT_LEN "\n", end_tuple, num_backend_rows);
RETURN(-1)
}
/* and enlarge the cache size */
"fetch %d in \"%s\"",
fetch_size, QR_get_cursor(self));
- mylog("%s: sending actual fetch (%d) query '%s'\n", func, fetch_size, fetch);
+ MYLOG(0, "%s: sending actual fetch (%d) query '%s'\n", func, fetch_size, fetch);
if (!boundary_adjusted)
{
QR_set_num_cached_rows(self, 0);
self->tupleField = NULL;
curr_eof = reached_eof_now = (QR_once_reached_eof(self) && self->cursTuple >= (Int4)self->num_total_read);
-inolog("reached_eof_now=%d\n", reached_eof_now);
+MYLOG(1, "reached_eof_now=%d\n", reached_eof_now);
- mylog("_%s: PGresult: fetch_total = %d & this_fetch = %d\n", func, self->num_total_read, self->num_cached_rows);
- mylog("_%s: PGresult: cursTuple = %d, offset = %d\n", func, self->cursTuple, offset);
+ 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);
cur_fetch = self->num_cached_rows - num_rows_in;
if (!ret)
num_backend_rows = self->num_cached_rows;
if (reached_eof_now)
{
- mylog("%s: reached eof now\n", func);
+ MYLOG(0, "%s: reached eof now\n", func);
QR_set_reached_eof(self);
if (self->ad_count > 0 && cur_fetch < fetch_size)
{
add_size = fetch_size - cur_fetch;
else if (add_size < 0)
add_size = 0;
-inolog("will add %d added_tuples from %d and select the %dth added tuple %d\n", add_size, start_idx, offset - num_backend_rows + start_idx, cur_fetch);
+MYLOG(1, "will add " FORMAT_LEN " added_tuples from " FORMAT_LEN " and select the " FORMAT_LEN "th added tuple " FORMAT_LEN "\n", add_size, start_idx, offset - num_backend_rows + start_idx, cur_fetch);
if (enlargeKeyCache(self, add_size, "Out of memory while adding tuples") < 0)
RETURN(FALSE)
/* append the KeySet info first */
else
{
/* We are surely done here (we read 0 tuples) */
- mylog("_%s: 'C': DONE (fcount == %d)\n", func, num_backend_rows);
+ MYLOG(0, "_%s: 'C': DONE (fcount == " FORMAT_LEN ")\n", func, num_backend_rows);
ret = -1; /* end of tuples */
}
}
for (i = 0; i < num_backend_rows; i++)
{
self->keyset[i].status &= (~CURS_NEEDS_REREAD);
-/*inolog("keyset[%d].status=%x\n", i, self->keyset[i].status);*/
+/*MYLOG(1, "keyset[%d].status=%x\n", i, self->keyset[i].status);*/
}
}
LEAVE_CONN_CS(conn);
#undef RETURN
#undef return
-inolog("%s returning %d offset=%d\n", func, ret, offset);
+MYLOG(1, "%s returning %d offset=" FORMAT_LEN "\n", func, ret, offset);
return ret;
}
memcpy(buffer, value, len);
buffer[len] = '\0';
- mylog("qresult: len=%d, buffer='%s'\n", len, buffer);
+ MYLOG(0, "qresult: len=%d, buffer='%s'\n", len, buffer);
if (field_lf >= effective_cols)
{
self->dataFilled = TRUE;
self->tupleField = self->backend_tuples + (self->fetch_number * self->num_fields);
-inolog("tupleField=%p\n", self->tupleField);
+MYLOG(1, "tupleField=%p\n", self->tupleField);
QR_set_rstatus(self, PORES_TUPLES_OK);
} while (0)
#define QR_set_next_in_cache(self, number) \
do { \
- inolog("set the number to %d to read next\n", number); \
+ MYLOG(1, "set the number to " FORMAT_LEN " to read next\n", number); \
self->fetch_number = number; \
} while (0)
#define QR_inc_next_in_cache(self) \
do { \
- inolog("increased the number %d", self->fetch_number); \
+ MYLOG(1, "increased the number " FORMAT_LEN, self->fetch_number); \
self->fetch_number++; \
- inolog("to %d to next read\n", self->fetch_number); \
+ MYLOG(1, "to " FORMAT_LEN " to next read\n", self->fetch_number); \
} while (0)
#define QR_get_message(self) ((self)->message ? (self)->message : (self)->messageref)
StatementClass *stmt = (StatementClass *) hstmt;
QResultClass *res;
- mylog("%s: entering...\n", func);
+ MYLOG(0, "%s: entering...\n", func);
if (!stmt)
{
SC_log_error(func, NULL_STRING, NULL);
if (stmt->proc_return > 0)
{
*pcrow = 0;
- inolog("returning RowCount=%d\n", *pcrow);
+ MYLOG(1, "returning RowCount=" FORMAT_LEN "\n", *pcrow);
return SQL_SUCCESS;
}
if (res->recent_processed_row_count >= 0)
{
*pcrow = res->recent_processed_row_count;
- mylog("**** %s: THE ROWS: *pcrow = %d\n", func, *pcrow);
+ MYLOG(0, "**** %s: THE ROWS: *pcrow = " FORMAT_LEN "\n", func, *pcrow);
return SQL_SUCCESS;
}
else if (QR_NumResultCols(res) > 0)
{
*pcrow = QR_get_cursor(res) ? -1 : QR_get_num_total_tuples(res) - res->dl_count;
- mylog("RowCount=%d\n", *pcrow);
+ MYLOG(0, "RowCount=" FORMAT_LEN "\n", *pcrow);
return SQL_SUCCESS;
}
}
num_fields = SC_describe(stmt);
result = SC_get_Curres(stmt);
- mylog("%s: result = %p, status = %d, numcols = %d\n", func, result, stmt->status, result != NULL ? QR_NumResultCols(result) : -1);
+ MYLOG(0, "%s: result = %p, status = %d, numcols = %d\n", func, 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)
{
FIELD_INFO *fi;
TABLE_INFO *ti = NULL;
-inolog("build_fi=%d reloid=%u\n", build_fi, reloid);
+MYLOG(1, "build_fi=%d reloid=%u\n", build_fi, reloid);
if (build_fi && 0 != QR_get_attid(result, col_idx))
getCOLIfromTI(func, NULL, stmt, reloid, &ti);
-inolog("nfields=%d\n", irdflds->nfields);
+MYLOG(1, "nfields=%d\n", irdflds->nfields);
if (irdflds->fi && col_idx < (int) irdflds->nfields)
{
fi = irdflds->fi[col_idx];
char parse_ok;
RETCODE ret = SQL_SUCCESS;
- mylog("%s: entering...\n", func);
+ MYLOG(0, "%s: entering...\n", func);
if (!stmt)
{
SC_log_error(func, NULL_STRING, NULL);
{
if (SC_parsed_status(stmt) == STMT_PARSE_NONE)
{
- mylog("%s: calling parse_statement on stmt=%p\n", func, stmt);
+ MYLOG(0, "%s: calling parse_statement on stmt=%p\n", func, stmt);
parse_statement(stmt, FALSE);
}
{
parse_ok = TRUE;
*pccol = SC_get_IRDF(stmt)->nfields;
- mylog("PARSE: %s: *pccol = %d\n", func, *pccol);
+ MYLOG(0, "PARSE: %s: *pccol = %d\n", func, *pccol);
}
}
int len = 0;
RETCODE result = SQL_SUCCESS;
- mylog("%s: entering.%d..\n", func, icol);
+ MYLOG(0, "%s: entering.%d..\n", func, icol);
if (!stmt)
{
{
SQLSMALLINT fType = stmt->options.use_bookmarks == SQL_UB_VARIABLE ? SQL_BINARY : SQL_INTEGER;
-inolog("answering bookmark info\n");
+MYLOG(1, "answering bookmark info\n");
if (szColName && cbColNameMax > 0)
*szColName = '\0';
if (pcbColName)
{
if (SC_parsed_status(stmt) == STMT_PARSE_NONE)
{
- mylog("%s: calling parse_statement on stmt=%p\n", func, stmt);
+ MYLOG(0, "%s: calling parse_statement on stmt=%p\n", func, stmt);
parse_statement(stmt, FALSE);
}
- mylog("PARSE: DescribeCol: icol=%d, stmt=%p, stmt->nfld=%d, stmt->fi=%p\n", icol, stmt, irdflds->nfields, irdflds->fi);
+ MYLOG(0, "PARSE: DescribeCol: 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("DescribeCol: getting info for icol=%d\n", icol);
+ MYLOG(0, "DescribeCol: getting info for icol=%d\n", icol);
}
}
decimal_digits = pgtype_decimal_digits(stmt, fieldtype, icol);
}
- mylog("PARSE: fieldtype=%d, col_name='%s', column_size=%d\n", fieldtype, NULL_IF_NULL(col_name), column_size);
+ MYLOG(0, "PARSE: fieldtype=%u, col_name='%s', column_size=" FORMAT_LEN "\n", fieldtype, NULL_IF_NULL(col_name), column_size);
}
else
{
decimal_digits = pgtype_decimal_digits(stmt, fieldtype, icol);
}
- mylog("describeCol: col %d fieldname = '%s'\n", icol, NULL_IF_NULL(col_name));
- mylog("describeCol: col %d fieldtype = %d\n", icol, fieldtype);
- mylog("describeCol: col %d column_size = %d\n", icol, column_size);
+ 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);
result = SQL_SUCCESS;
{
*pfSqlType = pgtype_to_concise_type(stmt, fieldtype, icol, unknown_sizes);
- mylog("describeCol: col %d *pfSqlType = %d\n", icol, *pfSqlType);
+ MYLOG(0, "describeCol: col %d *pfSqlType = %d\n", icol, *pfSqlType);
}
/*
*pcbColDef = column_size;
- mylog("describeCol: col %d *pcbColDef = %d\n", icol, *pcbColDef);
+ MYLOG(0, "describeCol: col %d *pcbColDef = " FORMAT_ULEN "\n", icol, *pcbColDef);
}
/*
decimal_digits = 0;
*pibScale = (SQLSMALLINT) decimal_digits;
- mylog("describeCol: col %d *pibScale = %d\n", icol, *pibScale);
+ MYLOG(0, "describeCol: col %d *pibScale = %d\n", icol, *pibScale);
}
/*
else
*pfNullable = fi ? fi->nullable : pgtype_nullable(conn, fieldtype);
- mylog("describeCol: col %d *pfNullable = %d\n", icol, *pfNullable);
+ MYLOG(0, "describeCol: col %d *pfNullable = %d\n", icol, *pfNullable);
}
cleanup:
QResultClass *res;
BOOL stmt_updatable;
- mylog("%s: entering..col=%d %d len=%d.\n", func, icol, fDescType,
+ MYLOG(0, "%s: entering..col=%d %d len=%d.\n", func, icol, fDescType,
cbDescMax);
if (!stmt)
res = SC_get_Curres(stmt);
if (0 == icol && SQL_DESC_COUNT != fDescType) /* bookmark column */
{
-inolog("answering bookmark info\n");
+MYLOG(1, "answering bookmark info\n");
switch (fDescType)
{
case SQL_DESC_OCTET_LENGTH:
{
if (SC_parsed_status(stmt) == STMT_PARSE_NONE)
{
- mylog("%s: calling parse_statement\n", func);
+ MYLOG(0, "%s: calling parse_statement\n", func);
parse_statement(stmt, FALSE);
}
field_type = getEffectiveOid(conn, fi);
}
- mylog("colAttr: col %d field_type=%d fi,ti=%p,%p\n", col_idx, field_type, fi, ti);
+ MYLOG(0, "colAttr: 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)
value = pgtype_auto_increment(conn, field_type);
if (value == -1) /* non-numeric becomes FALSE (ODBC Doc) */
value = FALSE;
- mylog("AUTO_INCREMENT=%d\n", value);
+ MYLOG(0, "AUTO_INCREMENT=" FORMAT_LEN "\n", value);
break;
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("%s: col %d, display_size= %d\n", func, col_idx, value);
+ MYLOG(0, "%s: col %d, display_size= " FORMAT_LEN "\n", func, col_idx, value);
break;
{
p = GET_NAME(fi->column_alias);
- mylog("%s: COLUMN_LABEL = '%s'\n", func, p);
+ MYLOG(0, "%s: COLUMN_LABEL = '%s'\n", func, p);
break;
}
/* otherwise same as column name -- FALL THROUGH!!! */
case SQL_DESC_NAME:
-inolog("fi=%p", fi);
+MYLOG(1, "fi=%p", fi);
if (fi)
-inolog(" (%s,%s)", PRINT_NAME(fi->column_alias), PRINT_NAME(fi->column_name));
+MYLOG(1, " (%s,%s)", PRINT_NAME(fi->column_alias), PRINT_NAME(fi->column_name));
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("%s: COLUMN_NAME = '%s'\n", func, p);
+ MYLOG(0, "%s: COLUMN_NAME = '%s'\n", func, p);
break;
case SQL_COLUMN_LENGTH:
/* if (-1 == value) I'm not sure which is right */
value = 0;
- mylog("%s: col %d, column_length = %d\n", func, col_idx, value);
+ MYLOG(0, "%s: col %d, column_length = " FORMAT_LEN "\n", func, col_idx, value);
break;
case SQL_COLUMN_MONEY: /* == SQL_DESC_FIXED_PREC_SCALE */
value = pgtype_money(conn, field_type);
-inolog("COLUMN_MONEY=%d\n", value);
+MYLOG(1, "COLUMN_MONEY=" FORMAT_LEN "\n", value);
break;
case SQL_DESC_NULLABLE:
value = TRUE;
else
value = fi ? fi->nullable : pgtype_nullable(conn, field_type);
-inolog("COLUMN_NULLABLE=%d\n", value);
+MYLOG(1, "COLUMN_NULLABLE=" FORMAT_LEN "\n", value);
break;
case SQL_COLUMN_OWNER_NAME: /* == SQL_DESC_SCHEMA_NAME */
p = ti ? SAFE_NAME(ti->schema_name) : NULL_STRING;
- mylog("%s: SCHEMA_NAME = '%s'\n", func, p);
+ MYLOG(0, "%s: SCHEMA_NAME = '%s'\n", func, p);
break;
case SQL_COLUMN_PRECISION: /* in 2.x */
if (value < 0)
value = 0;
- mylog("%s: col %d, column_size = %d\n", func, col_idx, value);
+ MYLOG(0, "%s: col %d, column_size = " FORMAT_LEN "\n", func, col_idx, value);
break;
case SQL_COLUMN_QUALIFIER_NAME: /* == SQL_DESC_CATALOG_NAME */
case SQL_COLUMN_SCALE: /* in 2.x */
value = pgtype_decimal_digits(stmt, field_type, col_idx);
-inolog("COLUMN_SCALE=%d\n", value);
+MYLOG(1, "COLUMN_SCALE=" FORMAT_LEN "\n", value);
if (value < 0)
value = 0;
break;
case SQL_COLUMN_TABLE_NAME: /* == SQL_DESC_TABLE_NAME */
p = ti ? SAFE_NAME(ti->table_name) : NULL_STRING;
- mylog("%s: TABLE_NAME = '%s'\n", func, p);
+ MYLOG(0, "%s: TABLE_NAME = '%s'\n", func, p);
break;
case SQL_COLUMN_TYPE: /* == SQL_DESC_CONCISE_TYPE */
value = pgtype_to_concise_type(stmt, field_type, col_idx, unknown_sizes);
- mylog("COLUMN_TYPE=%d\n", value);
+ MYLOG(0, "COLUMN_TYPE=" FORMAT_LEN "\n", value);
break;
case SQL_COLUMN_TYPE_NAME: /* == SQL_DESC_TYPE_NAME */
value = SQL_ATTR_READONLY;
}
- mylog("%s: UPDATEABLE = %d\n", func, value);
+ MYLOG(0, "%s: UPDATEABLE = " FORMAT_LEN "\n", func, value);
break;
case SQL_DESC_BASE_COLUMN_NAME:
p = fi ? SAFE_NAME(fi->column_name) : QR_get_fieldname(res, col_idx);
- mylog("%s: BASE_COLUMN_NAME = '%s'\n", func, p);
+ MYLOG(0, "%s: BASE_COLUMN_NAME = '%s'\n", func, p);
break;
case SQL_DESC_BASE_TABLE_NAME: /* the same as TABLE_NAME ok ? */
p = ti ? SAFE_NAME(ti->table_name) : NULL_STRING;
- mylog("%s: BASE_TABLE_NAME = '%s'\n", func, p);
+ MYLOG(0, "%s: BASE_TABLE_NAME = '%s'\n", func, 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("%s: col %d, desc_length = %d\n", func, col_idx, value);
+ MYLOG(0, "%s: col %d, desc_length = " FORMAT_LEN "\n", func, 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("%s: col %d, octet_length = %d\n", func, col_idx, value);
+ MYLOG(0, "%s: col %d, octet_length = " FORMAT_LEN "\n", func, 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("%s: col %d, desc_precision = %d\n", func, col_idx, value);
+ MYLOG(0, "%s: col %d, desc_precision = " FORMAT_LEN "\n", func, 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("%s:SS_COLUMN_KEY=%d\n", func, value);
+ MYLOG(0, "%s:SS_COLUMN_KEY=" FORMAT_LEN "\n", func, 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("%s: enter, stmt=%p icol=%d\n", func, stmt, icol);
+ MYLOG(0, "%s: enter, stmt=%p icol=%d\n", func, stmt, icol);
if (!stmt)
{
if (binfo)
{
target_type = binfo->returntype;
- mylog("SQL_ARD_TYPE=%d\n", target_type);
+ MYLOG(0, "SQL_ARD_TYPE=%d\n", target_type);
precision = binfo->precision;
}
else
case SQL_C_VARBOOKMARK:
break;
default:
-inolog("GetData Column 0 is type %d not of type SQL_C_BOOKMARK", target_type);
+MYLOG(1, "GetData Column 0 is type %d not of type SQL_C_BOOKMARK", target_type);
SC_set_error(stmt, STMT_PROGRAM_TYPE_OUT_OF_RANGE, "Column 0 is not of type SQL_C_BOOKMARK", func);
return SQL_ERROR;
}
result = SQL_ERROR;
goto cleanup;
}
- mylog(" num_rows = %d\n", num_rows);
+ MYLOG(0, " num_rows = " FORMAT_LEN "\n", num_rows);
if (!get_bookmark)
{
SQLLEN curt = GIdx2CacheIdx(stmt->currTuple, stmt, res);
value = QR_get_value_backend_row(res, curt, icol);
-inolog("currT=%d base=%d rowset=%d\n", stmt->currTuple, QR_get_rowstart_in_cache(res), SC_get_rowset_start(stmt));
- mylog(" value = '%s'\n", NULL_IF_NULL(value));
+MYLOG(1, "currT=" FORMAT_LEN " base=" FORMAT_LEN " rowset=" FORMAT_LEN "\n", stmt->currTuple, QR_get_rowstart_in_cache(res), SC_get_rowset_start(stmt));
+ MYLOG(0, " value = '%s'\n", NULL_IF_NULL(value));
}
}
else
SQLLEN curt = GIdx2CacheIdx(stmt->currTuple, stmt, res);
value = QR_get_value_backend_row(res, curt, icol);
}
- mylog(" socket: value = '%s'\n", NULL_IF_NULL(value));
+ MYLOG(0, " socket: value = '%s'\n", NULL_IF_NULL(value));
}
if (get_bookmark)
field_type = QR_get_field_type(res, icol);
atttypmod = QR_get_atttypmod(res, icol);
- mylog("**** %s: icol = %d, target_type = %d, field_type = %d, value = '%s'\n", func, icol, target_type, field_type, NULL_IF_NULL(value));
+ MYLOG(0, "**** %s: icol = %d, target_type = %d, field_type = %d, value = '%s'\n", func, icol, target_type, field_type, NULL_IF_NULL(value));
SC_set_current_col(stmt, icol);
cleanup:
#undef return
-inolog("%s returning %d\n", __FUNCTION__, result);
+MYLOG(1, "%s returning %d\n", __FUNCTION__, result);
return result;
}
BindInfoClass *bookmark;
RETCODE retval = SQL_SUCCESS;
- mylog("%s: stmt = %p, stmt->result= %p\n", func, stmt, stmt ? SC_get_Curres(stmt) : NULL);
+ MYLOG(0, "%s: stmt = %p, stmt->result= %p\n", func, stmt, stmt ? SC_get_Curres(stmt) : NULL);
if (!stmt)
{
if (!QR_once_reached_eof(res))
num_tuples = INT_MAX;
/* Note that the parameter nth is 1-based */
-inolog("get %dth Valid data from %d to %s [dlt=%d]", nth, sta, orientation == SQL_FETCH_PRIOR ? "backward" : "forward", res->dl_count);
+MYLOG(1, "get " FORMAT_ULEN "th Valid data from " FORMAT_LEN " to %s [dlt=%d]", nth, sta, orientation == SQL_FETCH_PRIOR ? "backward" : "forward", res->dl_count);
if (0 == res->dl_count)
{
if (SQL_FETCH_PRIOR == orientation)
delsta = (-1);
for (i = res->dl_count - 1; i >=0 && *nearest <= deleted[i]; i--)
{
-inolog("deleted[%d]=%d\n", i, deleted[i]);
+MYLOG(1, "deleted[" FORMAT_LEN "]=" FORMAT_LEN "\n", i, deleted[i]);
if (sta >= deleted[i])
{
(*nearest)--;
delsta = i;
}
}
-inolog("nearest=%d\n", *nearest);
+MYLOG(1, "nearest=" FORMAT_LEN "\n", *nearest);
if (*nearest < 0)
{
*nearest = -1;
if (0 == (keyset->status & (CURS_SELF_DELETING | CURS_SELF_DELETED | CURS_OTHER_DELETED)))
{
*nearest = i;
-inolog(" nearest=%d\n", *nearest);
+MYLOG(1, " nearest=" FORMAT_LEN "\n", *nearest);
if (++count == nth)
return count;
}
if (0 == (keyset->status & (CURS_SELF_DELETING | CURS_SELF_DELETED | CURS_OTHER_DELETED)))
{
*nearest = i;
-inolog(" nearest=%d\n", *nearest);
+MYLOG(1, " nearest=" FORMAT_LEN "\n", *nearest);
if (++count == nth)
return count;
}
}
*nearest = num_tuples;
}
-inolog(" nearest not found\n");
+MYLOG(1, " nearest not found\n");
return -(SQLLEN)count;
}
res->move_offset = 0;
return;
}
-inolog("BASE=%d numb=%d curr=%d cursT=%d\n", QR_get_rowstart_in_cache(res), res->num_cached_rows, self->currTuple, res->cursTuple);
+MYLOG(1, "BASE=" FORMAT_LEN " numb=" FORMAT_LEN " curr=" FORMAT_LEN " cursT=" FORMAT_LEN "\n", QR_get_rowstart_in_cache(res), res->num_cached_rows, self->currTuple, res->cursTuple);
/* normal case */
res->move_offset = 0;
*/
#define EXTFETCH_RETURN_BOF(stmt, res) \
{ \
-inolog("RETURN_BOF\n"); \
+MYLOG(1, "RETURN_BOF\n"); \
SC_set_rowset_start(stmt, -1, TRUE); \
stmt->currTuple = -1; \
/* move_cursor_position_if_needed(stmt, res); */ \
}
#define EXTFETCH_RETURN_EOF(stmt, res) \
{ \
-inolog("RETURN_EOF\n"); \
+MYLOG(1, "RETURN_EOF\n"); \
SC_set_rowset_start(stmt, num_tuples, TRUE); \
stmt->currTuple = -1; \
/* move_cursor_position_if_needed(stmt, res); */ \
BOOL currp_is_valid, reached_eof, useCursor;
SQLLEN reqsize = rowsetSize;
- mylog("%s: stmt=%p rowsetSize=%d\n", func, stmt, rowsetSize);
+ MYLOG(0, "%s: stmt=%p rowsetSize=" FORMAT_LEN "\n", func, stmt, rowsetSize);
if (!stmt)
{
if (useCursor && !reached_eof)
num_tuples = INT_MAX;
-inolog("num_tuples=%d\n", num_tuples);
+MYLOG(1, "num_tuples=" FORMAT_LEN "\n", num_tuples);
/* Save and discard the saved rowset size */
save_rowset_size = stmt->save_rowset_size;
stmt->save_rowset_size = -1;
}
else
SC_inc_rowset_start(stmt, progress_size);
- mylog("SQL_FETCH_NEXT: num_tuples=%d, currtuple=%d, rowst=%d\n", num_tuples, stmt->currTuple, rowset_start);
+ MYLOG(0, "SQL_FETCH_NEXT: num_tuples=" FORMAT_LEN ", currtuple=" FORMAT_LEN ", rowst=" FORMAT_LEN "\n", num_tuples, stmt->currTuple, rowset_start);
break;
case SQL_FETCH_PRIOR:
- mylog("SQL_FETCH_PRIOR: num_tuples=%d, currtuple=%d\n", num_tuples, stmt->currTuple);
+ MYLOG(0, "SQL_FETCH_PRIOR: num_tuples=" FORMAT_LEN ", currtuple=" FORMAT_LEN "\n", num_tuples, stmt->currTuple);
/*
* From the odbc spec... If positioned after the end of the
break;
case SQL_FETCH_FIRST:
- mylog("SQL_FETCH_FIRST: num_tuples=%d, currtuple=%d\n", num_tuples, stmt->currTuple);
+ MYLOG(0, "SQL_FETCH_FIRST: num_tuples=" FORMAT_LEN ", currtuple=" FORMAT_LEN "\n", num_tuples, stmt->currTuple);
SC_set_rowset_start(stmt, 0, TRUE);
break;
case SQL_FETCH_LAST:
- mylog("SQL_FETCH_LAST: num_tuples=%d, currtuple=%d\n", num_tuples, stmt->currTuple);
+ MYLOG(0, "SQL_FETCH_LAST: num_tuples=" FORMAT_LEN ", currtuple=" FORMAT_LEN "\n", num_tuples, stmt->currTuple);
if (!reached_eof)
{
break;
case SQL_FETCH_ABSOLUTE:
- mylog("SQL_FETCH_ABSOLUTE: num_tuples=%d, currtuple=%d, irow=%d\n", num_tuples, stmt->currTuple, irow);
+ MYLOG(0, "SQL_FETCH_ABSOLUTE: num_tuples=" FORMAT_LEN ", currtuple=" FORMAT_LEN ", irow=" FORMAT_LEN "\n", num_tuples, stmt->currTuple, irow);
/* Position before result set, but dont fetch anything */
if (irow == 0)
}
/* Physical Row advancement occurs for each row fetched below */
- mylog("PGAPI_ExtendedFetch: new currTuple = %d\n", stmt->currTuple);
+ MYLOG(0, "PGAPI_ExtendedFetch: new currTuple = " FORMAT_LEN "\n", stmt->currTuple);
truncated = error = FALSE;
if (SQL_NO_DATA_FOUND != result && res->keyset)
{
currp = GIdx2KResIdx(SC_get_rowset_start(stmt), stmt, res);
-inolog("currp=%d\n", currp);
+MYLOG(1, "currp=" FORMAT_LEN "\n", currp);
if (currp < 0)
{
result = SQL_ERROR;
- mylog("rowset_start=%d but currp=%d\n", SC_get_rowset_start(stmt), currp);
+ MYLOG(0, "rowset_start=" FORMAT_LEN " but currp=" FORMAT_LEN "\n", SC_get_rowset_start(stmt), currp);
SC_set_error(stmt, STMT_INTERNAL_ERROR, "rowset_start not in the keyset", func);
goto cleanup;
}
}
else
{
- mylog("Umm current row is out of keyset\n");
+ MYLOG(0, "Umm current row is out of keyset\n");
break;
}
}
-inolog("ExtFetch result=%d\n", result);
+MYLOG(1, "ExtFetch result=%d\n", result);
if (currp_is_valid && SQL_SUCCESS_WITH_INFO == result && 0 == stmt->last_fetch_count)
{
-inolog("just skipping deleted row %d\n", currp);
+MYLOG(1, "just skipping deleted row " FORMAT_LEN "\n", currp);
if (rowsetSize - i + fc_io > reqsize)
QR_set_reqsize(res, (Int4) (rowsetSize - i + fc_io));
result = SC_fetch(stmt);
/* Set the number of rows retrieved */
if (pcrow)
*pcrow = i;
-inolog("pcrow=%d\n", i);
+MYLOG(1, "pcrow=" FORMAT_LEN "\n", i);
if (i == 0)
/* Only DeclareFetch should wind up here */
QResultClass *res;
RETCODE ret = SQL_SUCCESS;
- mylog("%s: entering...\n", func);
+ MYLOG(0, "%s: entering...\n", func);
res = SC_get_Curres(stmt);
if (res)
{
PGAPI_FreeStmt(hstmt, SQL_CLOSE);
ret = SQL_NO_DATA_FOUND;
}
- mylog("%s: returning %d\n", func, ret);
+ MYLOG(0, "%s: returning %d\n", func, ret);
return ret;
}
if (!CC_is_in_trans(conn))
return;
-inolog("AddRollback %d(%u,%u) %s\n", index, keyset->blocknum, keyset->offset, dmlcode == SQL_ADD ? "ADD" : (dmlcode == SQL_UPDATE ? "UPDATE" : (dmlcode == SQL_DELETE ? "DELETE" : "REFRESH")));
+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")));
if (!res->rollback)
{
res->rb_count = 0;
{
if (tuple->value)
{
-inolog("freeing tuple[%d][%d].value=%p\n", i / num_fields, i % num_fields, tuple->value);
+MYLOG(1, "freeing tuple[" FORMAT_LEN "][" FORMAT_LEN "].value=%p\n", i / num_fields, i % num_fields, tuple->value);
free(tuple->value);
tuple->value = NULL;
}
{
SQLLEN i;
-inolog("ReplaceCachedRows %p num_fields=%d num_rows=%d\n", otuple, num_fields, num_rows);
+MYLOG(1, "ReplaceCachedRows %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 (ituple->value)
{
otuple->value = strdup(ituple->value);
-inolog("[%d,%d] %s copied\n", i / num_fields, i % num_fields, otuple->value);
+MYLOG(1, "[" FORMAT_LEN "," FORMAT_LEN "] %s copied\n", i / num_fields, i % num_fields, (const char *) otuple->value);
}
if (otuple->value)
otuple->len = ituple->len;
{
int i;
-inolog("MoveCachedRows %p num_fields=%d num_rows=%d\n", otuple, num_fields, num_rows);
+MYLOG(1, "MoveCachedRows %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)
{
otuple->value = ituple->value;
ituple->value = NULL;
-inolog("[%d,%d] %s copied\n", i / num_fields, i % num_fields, otuple->value);
+MYLOG(1, "[%d,%d] %s copied\n", i / num_fields, i % num_fields, (const char *) otuple->value);
}
otuple->len = ituple->len;
ituple->len = -1;
if (!res) return;
num_fields = res->num_fields;
-inolog("AddAdded index=%d, tuple=%p, num_fields=%d\n", index, tuple_added, num_fields);
+MYLOG(1, "AddAdded 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("RemoveAdded index=%d\n", index);
+ MYLOG(0, "RemoveAdded index=" FORMAT_LEN "\n", index);
if (index < 0)
rmidx = -index - 1;
else
RemoveDeleted(res, index);
RemoveUpdated(res, index);
res->ad_count--;
- mylog("RemoveAdded removed=1 count=%d\n", res->ad_count);
+ MYLOG(0, "RemoveAdded removed=1 count=%d\n", res->ad_count);
}
static void
int i;
UWORD status;
- mylog("CommitAdded res=%p\n", res);
+ MYLOG(0, "CommitAdded res=%p\n", res);
if (!res || !res->added_keyset) return;
added_keyset = res->added_keyset;
for (i = res->ad_count - 1; i >= 0; i--)
}
if (status != added_keyset[i].status)
{
-inolog("!!Commit Added=%d(%d)\n", QR_get_num_total_read(res) + i, i);
+MYLOG(1, "!!Commit Added=" FORMAT_ULEN "(%d)\n", QR_get_num_total_read(res) + i, i);
added_keyset[i].status = status;
}
}
UWORD status;
Int2 num_fields = res->num_fields;
-inolog("AddDeleted %d\n", index);
+MYLOG(1, "AddDeleted " 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("RemoveDeleted index=%d\n", index);
+ MYLOG(0, "RemoveDeleted index=" FORMAT_LEN "\n", index);
if (index < 0)
{
midx = index;
rm_count++;
}
}
- mylog("RemoveDeleted removed count=%d,%d\n", rm_count, res->dl_count);
+ MYLOG(0, "RemoveDeleted removed count=%d,%d\n", rm_count, res->dl_count);
}
static void
}
if (status != deleted_keyset->status)
{
-inolog("!!Commit Deleted=%d(%d)\n", *deleted, i);
+MYLOG(1, "!!Commit Deleted=" FORMAT_LEN "(%d)\n", *deleted, i);
deleted_keyset->status = status;
}
}
int i;
UWORD status;
-inolog("AddUpdated index=%d\n", index);
+MYLOG(1, "AddUpdated index=" FORMAT_LEN "\n", index);
if (!stmt) return;
if (res = SC_get_Curres(stmt), !res) return;
if (!keyset) return;
ReplaceCachedRows(tuple, tuple_updated, num_fields, 1);
if (is_in_trans)
SC_get_conn(stmt)->result_uncommitted = 1;
- mylog("up_count=%d\n", res->up_count);
+ MYLOG(0, "up_count=%d\n", res->up_count);
}
static void
RemoveUpdated(QResultClass *res, SQLLEN index)
{
- mylog("RemoveUpdated index=%d\n", index);
+ MYLOG(0, "RemoveUpdated 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("RemoveUpdatedAfterTheKey %d,(%u,%u)\n", index, keyset ? keyset->blocknum : 0, keyset ? keyset->offset : 0);
+ MYLOG(0, "RemoveUpdatedAfterTheKey " FORMAT_LEN ",(%u,%u)\n", index, keyset ? keyset->blocknum : 0, keyset ? keyset->offset : 0);
if (index < 0)
{
midx = index;
rm_count++;
}
}
- mylog("RemoveUpdatedAfter removed count=%d,%d\n", rm_count, res->up_count);
+ MYLOG(0, "RemoveUpdatedAfter removed count=%d,%d\n", rm_count, res->up_count);
}
static void
int i;
UWORD status;
- mylog("CommitUpdated res=%p\n", res);
+ MYLOG(0, "CommitUpdated res=%p\n", res);
if (!res) return;
if (!QR_get_cursor(res))
return;
}
if (status != updated_keyset[i].status)
{
-inolog("!!Commit Updated=%d(%d)\n", res->updated[i], i);
+MYLOG(1, "!!Commit Updated=" FORMAT_LEN "(%d)\n", res->updated[i], i);
updated_keyset[i].status = status;
}
}
KeySet *keyset;
BOOL kres_is_valid;
-inolog("DiscardRollback");
+MYLOG(1, "DiscardRollback");
if (QR_get_cursor(res))
{
CommitAdded(res);
keys.offset = rollback[i].offset;
keys.oid = rollback[i].oid;
texist = tupleExists(stmt, &keys);
-inolog("texist[%d]=%d", i, texist);
+MYLOG(1, "texist[%d]=%d", i, texist);
if (SQL_ADD == rollback[i].option)
{
if (texist)
if (doubtp == i)
doubtp = i + 1;
}
-inolog(" doubtp=%d\n", doubtp);
+MYLOG(1, " doubtp=%d\n", doubtp);
}
rollbp = i;
-inolog(" doubtp=%d,rollbp=%d\n", doubtp, rollbp);
+MYLOG(1, " doubtp=%d,rollbp=%d\n", doubtp, rollbp);
do
{
rollbps = rollbp;
index = rollback[i].index;
if (SQL_ADD == rollback[i].option)
{
-inolog("index[%d]=%d\n", i, index);
+MYLOG(1, "index[%d]=" FORMAT_LEN "\n", i, index);
if (index < 0)
{
midx = index;
pidx = index;
midx = res->num_total_read - index - 1;
}
-inolog("pidx=%d,midx=%d\n", pidx, midx);
+MYLOG(1, "pidx=" FORMAT_LEN ",midx=" FORMAT_LEN "\n", pidx, midx);
for (j = rollbp - 1; j > i; j--)
{
if (rollback[j].index == midx ||
{
if (SQL_DELETE == rollback[j].option)
{
-inolog("delete[%d].index=%d\n", j, rollback[j].index);
+MYLOG(1, "delete[%d].index=" FORMAT_LEN "\n", j, rollback[j].index);
break;
}
/*else if (SQL_UPDATE == rollback[j].option)
{
-inolog("update[%d].index=%d\n", j, rollback[j].index);
+MYLOG(1, "update[%d].index=%d\n", j, rollback[j].index);
if (IndexExists(stmt, res, rollback + j))
break;
}*/
}
} while (rollbp < rollbps);
}
-inolog("rollbp=%d\n", rollbp);
+MYLOG(1, "rollbp=%d\n", rollbp);
for (i = res->rb_count - 1; i >= rollbp; i--)
{
-inolog("UndoRollback %d(%d)\n", i, rollback[i].option);
+MYLOG(1, "UndoRollback %d(%d)\n", i, rollback[i].option);
index = rollback[i].index;
if (curs)
{
status = wkey->status;
}
}
-inolog(" index=%d status=%hx", index, status);
+MYLOG(1, " index=" FORMAT_LEN " status=%hx", index, status);
if (kres_is_valid)
{
QResultClass *qres;
continue;
else
{
-inolog(" (%u, %u)", wkey->blocknum, wkey->offset);
+MYLOG(1, " (%u, %u)", wkey->blocknum, wkey->offset);
wkey->blocknum = rollback[i].blocknum;
wkey->offset = rollback[i].offset;
wkey->oid = rollback[i].oid;
-inolog("->(%u, %u)\n", wkey->blocknum, wkey->offset);
+MYLOG(1, "->(%u, %u)\n", wkey->blocknum, wkey->offset);
wkey->status &= ~KEYSET_INFO_PUBLIC;
if (SQL_DELETE == rollback[i].option)
wkey->status &= ~CURS_SELF_DELETING;
const ssize_t from_pos = stmt->load_from_pos;
const char *load_stmt = stmt->load_statement;
-inolog("%s bestitem=%s bestqual=%s\n", func, SAFE_NAME(ti->bestitem), SAFE_NAME(ti->bestqual));
+MYLOG(1, "%s bestitem=%s bestqual=%s\n", func, SAFE_NAME(ti->bestitem), SAFE_NAME(ti->bestqual));
initPQExpBuffer(&selstr);
#define return DONT_CALL_RETURN_FROM_HERE???
if (TI_has_subclass(ti))
SC_set_error(stmt, STMT_NO_MEMORY_ERROR, "Could not allocate memory positioned_load()", func);
goto cleanup;
}
- mylog("selstr=%s\n", selstr.data);
+ MYLOG(0, "selstr=%s\n", selstr.data);
qres = CC_send_query(SC_get_conn(stmt), selstr.data, NULL, READ_ONLY_QUERY, stmt);
cleanup:
#undef return
BOOL use_ctid = TRUE;
BOOL idx_exist = TRUE;
- mylog("positioned load fi=%p ti=%p\n", irdflds->fi, stmt->ti);
+ MYLOG(0, "positioned load fi=%p ti=%p\n", irdflds->fi, stmt->ti);
rcnt = 0;
if (count)
*count = 0;
if (NULL == keyset || keyset->offset == 0)
{
use_ctid = FALSE;
- mylog("The tuple is currently being added and can't use ctid\n");
+ MYLOG(0, "The tuple is currently being added and can't use ctid\n");
}
}
const char *load_stmt = stmt->load_statement;
const ssize_t from_pos = stmt->load_from_pos;
-mylog(" %s in rows_per_fetch=%d limitrow=%d\n", __FUNCTION__, rows_per_fetch, limitrow);
+MYLOG(0, " %s in rows_per_fetch=%d limitrow=" FORMAT_LEN "\n", __FUNCTION__, 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("%s\n", func);
+ MYLOG(0, "%s\n", func);
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("positioned new ti=%p\n", stmt->ti);
+ MYLOG(0, "positioned new 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);
appendData = TRUE;
else
{
-inolog("total %d <> backend %d - base %d + start %d cursor_type=%d\n",
+MYLOG(1, "total " FORMAT_LEN " <> backend " FORMAT_LEN " - base " FORMAT_LEN " + start " FORMAT_LEN " cursor_type=%d\n",
num_total_rows, num_cached_rows,
QR_get_rowstart_in_cache(res), SC_get_rowset_start(stmt), stmt->options.cursor_type);
}
}
if (appendData)
{
-inolog("total %d == backend %d - base %d + start %d cursor_type=%d\n",
+MYLOG(1, "total " FORMAT_LEN " == backend " FORMAT_LEN " - base " FORMAT_LEN " + start " FORMAT_LEN " cursor_type=%d\n",
num_total_rows, num_cached_rows,
QR_get_rowstart_in_cache(res), SC_get_rowset_start(stmt), stmt->options.cursor_type);
if (num_cached_rows >= res->count_backend_allocated)
if (s->updyes)
{
- mylog("pos_update_callback in\n");
+ MYLOG(0, "pos_update_callback in\n");
ret = irow_update(ret, s->stmt, s->qstmt, s->global_ridx, &s->old_keyset);
-inolog("irow_update ret=%d,%d\n", ret, SC_get_errornumber(s->qstmt));
+MYLOG(1, "irow_update ret=%d,%d\n", ret, SC_get_errornumber(s->qstmt));
if (ret != SQL_SUCCESS)
SC_error_copy(s->stmt, s->qstmt, TRUE);
PGAPI_FreeStmt(s->qstmt, SQL_DROP);
SC_set_error(s.stmt, STMT_INVALID_CURSOR_STATE_ERROR, "Null statement result in SC_pos_update.", func);
return SQL_ERROR;
}
- mylog("POS UPDATE %d+%d fi=%p ti=%p\n", s.irow, QR_get_rowstart_in_cache(s.res), fi, s.stmt->ti);
+ 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);
if (SC_update_not_ready(stmt))
parse_statement(s.stmt, TRUE); /* not preferable */
if (!SC_is_updatable(s.stmt))
used = LENADDR_SHIFT(used, bind_size * s.irow);
else
used = LENADDR_SHIFT(used, s.irow * sizeof(SQLLEN));
- mylog("%d used=%d,%p\n", i, *used, used);
+ MYLOG(0, "%d used=" FORMAT_LEN ",%p\n", i, *used, used);
if (*used != SQL_IGNORE && fi[i]->updatable)
{
if (upd_cols)
}
}
else
- mylog("%d null bind\n", i);
+ MYLOG(0, "%d null bind\n", i);
}
conn = SC_get_conn(s.stmt);
s.updyes = FALSE;
appendPQExpBuffer(&updstr, "\"%s\"", bestitem);
}
}
- mylog("updstr=%s\n", updstr);
+ MYLOG(0, "updstr=%s\n", updstr.data);
if (PGAPI_AllocStmt(conn, &hstmt, 0) != SQL_SUCCESS)
{
SC_set_error(s.stmt, STMT_NO_MEMORY_ERROR, "internal AllocStmt error", func);
used = LENADDR_SHIFT(used, bind_size * s.irow);
else
used = LENADDR_SHIFT(used, s.irow * sizeof(SQLLEN));
- mylog("%d used=%d\n", i, *used);
+ MYLOG(0, "%d used=" FORMAT_LEN "\n", i, *used);
if (*used != SQL_IGNORE && fi[i]->updatable)
{
/* fieldtype = QR_get_field_type(s.res, i); */
BOOL idx_exist = TRUE;
char table_fqn[256];
- mylog("POS DELETE ti=%p\n", stmt->ti);
+ MYLOG(0, "POS DELETE 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);
SC_set_error(stmt, STMT_NO_MEMORY_ERROR, "Out of memory in SC_pos_delete()", func);
goto cleanup;
}
- mylog("dltstr=%s\n", dltstr.data);
+ MYLOG(0, "dltstr=%s\n", dltstr.data);
qflag = 0;
if (stmt->external && !CC_is_in_trans(conn) &&
(!CC_does_autocommit(conn)))
}
else
res->keyset[kres_ridx].status |= (SQL_ROW_DELETED | CURS_SELF_DELETED);
-inolog(".status[%d]=%x\n", global_ridx, res->keyset[kres_ridx].status);
+MYLOG(1, ".status[" FORMAT_ULEN "]=%x\n", global_ridx, res->keyset[kres_ridx].status);
}
if (irdflds->rowStatusArray)
{
{
SQLSETPOSIROW brow_save;
- mylog("pos_add_callback in ret=%d\n", ret);
+ MYLOG(0, "pos_add_callback in 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("POS ADD fi=%p ti=%p\n", fi, stmt->ti);
+ MYLOG(0, "POS ADD fi=%p ti=%p\n", fi, stmt->ti);
s.stmt = stmt;
s.irow = irow;
if (!(s.res = SC_get_Curres(s.stmt)))
used = LENADDR_SHIFT(used, bind_size * s.irow);
else
used = LENADDR_SHIFT(used, s.irow * sizeof(SQLLEN));
- mylog("%d used=%d\n", i, *used);
+ MYLOG(0, "%d used=" FORMAT_LEN "\n", i, *used);
if (*used != SQL_IGNORE && fi[i]->updatable)
{
/* fieldtype = QR_get_field_type(s.res, i); */
}
}
else
- mylog("%d null bind\n", i);
+ MYLOG(0, "%d null bind\n", i);
}
s.updyes = FALSE;
ENTER_INNER_CONN_CS(conn, func_cs_count);
SC_set_error(stmt, STMT_NO_MEMORY_ERROR, "Out of memory in SC_pos_add()", func);
goto cleanup;
}
+ MYLOG(0, "addstr=%s\n", addstr.data);
mylog("addstr=%s\n", addstr.data);
s.qstmt->exec_start_row = s.qstmt->exec_end_row = s.irow;
s.updyes = TRUE;
SQLLEN kres_ridx, pos_ridx = 0;
ret = retcode;
- mylog("%s: %d in\n", func, s->need_data_callback);
+ MYLOG(0, "%s: %d in\n", func, s->need_data_callback);
if (s->need_data_callback)
{
s->processed++;
res->recent_processed_row_count = s->stmt->diag_row_count = s->processed;
if (opts)
{
-inolog("processed=%d ret=%d rowset=%d", s->processed, ret, opts->size_of_rowset_odbc2);
-inolog(",%d\n", opts->size_of_rowset);
+MYLOG(1, "processed=" FORMAT_POSIROW " ret=%d rowset=" FORMAT_LEN, s->processed, ret, opts->size_of_rowset_odbc2);
+MYLOG(1, "," FORMAT_LEN "\n", opts->size_of_rowset);
}
return ret;
s.opts = SC_get_ARDF(s.stmt);
gdata_info = SC_get_GDTI(s.stmt);
gdata = gdata_info->gdata;
- mylog("%s fOption=%d irow=%d lock=%d currt=%d\n", func, s.fOption, s.irow, fLock, s.stmt->currTuple);
+ MYLOG(0, "%s fOption=%d irow=" FORMAT_POSIROW " lock=%hu currt=" FORMAT_LEN "\n", func, 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)
}
gdata_allocated = gdata_info->allocated;
-mylog("num_cols=%d gdatainfo=%d\n", QR_NumPublicResultCols(s.res), gdata_allocated);
+MYLOG(0, "num_cols=%d gdatainfo=%d\n", QR_NumPublicResultCols(s.res), gdata_allocated);
/* Reset for SQLGetData */
if (gdata)
{
SC_set_error(s.stmt, STMT_ROW_OUT_OF_RANGE, "the row was deleted?", func);
ret = SQL_ERROR;
}
- mylog("%s returning %d\n", func, ret);
+ MYLOG(0, "%s returning %d\n", func, ret);
return ret;
}
CSTR func = "PGAPI_SetScrollOptions";
StatementClass *stmt = (StatementClass *) hstmt;
- mylog("%s: fConcurrency=%d crowKeyset=%d crowRowset=%d\n",
+ MYLOG(0, "%s: fConcurrency=%d crowKeyset=" FORMAT_LEN " crowRowset=%d\n",
func, fConcurrency, crowKeyset, crowRowset);
SC_set_error(stmt, STMT_NOT_IMPLEMENTED_ERROR, "SetScroll option not implemeted", func);
CSTR func = "PGAPI_SetCursorName";
StatementClass *stmt = (StatementClass *) hstmt;
- mylog("%s: hstmt=%p, szCursor=%p, cbCursorMax=%d\n", func, hstmt, szCursor, cbCursor);
+ MYLOG(0, "%s: hstmt=%p, szCursor=%p, cbCursorMax=%d\n", func, hstmt, szCursor, cbCursor);
if (!stmt)
{
size_t len = 0;
RETCODE result;
- mylog("%s: hstmt=%p, szCursor=%p, cbCursorMax=%d, pcbCursor=%p\n", func, hstmt, szCursor, cbCursorMax, pcbCursor);
+ MYLOG(0, "%s: hstmt=%p, szCursor=%p, cbCursorMax=%d, pcbCursor=%p\n", func, hstmt, szCursor, cbCursorMax, pcbCursor);
if (!stmt)
{
TupleField *otuple, *ituple;
SQLUSMALLINT *rowStatusArray;
- mylog("%s in\n", __FUNCTION__);
+ MYLOG(0, "%s in\n", __FUNCTION__);
if (!(res = SC_get_Curres(stmt)))
{
pg_bm = SC_Resolve_bookmark(opts, i);
bidx = pg_bm.index;
-mylog("i=%d bidx=%d cached=%d\n", i, bidx, res->num_cached_keys);
+MYLOG(0, "i=%d bidx=" FORMAT_LEN " cached=" FORMAT_ULEN "\n", i, bidx, res->num_cached_keys);
kres_ridx = GIdx2KResIdx(bidx, stmt, res);
if (kres_ridx < 0 || kres_ridx >= res->num_cached_keys)
{
getTid(res, kres_ridx, &blocknum, &offset);
}
snprintf(tidbuf + i * tidbuflen, tidbuflen, "(%u,%u)", blocknum, offset);
- mylog("!!!! tidbuf=%s\n", tidbuf + i * tidbuflen);
+ MYLOG(0, "!!!! tidbuf=%s\n", tidbuf + i * tidbuflen);
}
if (!SQL_SUCCEEDED(PGAPI_BindParameter(hstmt, 1, SQL_PARAM_INPUT,
SQL_C_CHAR, SQL_CHAR, tidbuflen, 0,
opts->bookmark = NULL;
ret = PGAPI_ExtendedFetch(fstmt, SQL_FETCH_NEXT, 0,
&cRow, NULL, 0, size_of_rowset);
- mylog("%s cRow=" FORMAT_ULEN "\n", __FUNCTION__, cRow);
+ MYLOG(0, "%s cRow=" FORMAT_ULEN "\n", __FUNCTION__, cRow);
cleanup:
if (NULL != hstmt)
dsn_1st = ci->dsn[0];
ci->dsn[0] = '\0';
makeConnectString(out_conn, ci, sizeof(out_conn));
-mylog("conn_string=%s\n", out_conn);
+MYLOG(0, "conn_string=%s\n", out_conn);
#ifdef UNICODE_SUPPORT
MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, out_conn, -1, wout_conn, sizeof(wout_conn) / sizeof(wout_conn[0]));
conn_str = wout_conn;
/* lpsetupdlg->aAttr[iElement].fSupplied = TRUE; */
memcpy(value, lpszStart, MIN(lpsz - lpszStart + 1, MAXPGPATH));
- mylog("aszKey='%s', value='%s'\n", aszKey, value);
+ MYLOG(0, "aszKey='%s', value='%s'\n", aszKey, value);
/* Copy the appropriate value to the conninfo */
copyConnAttributes(&lpsetupdlg->ci, aszKey, value);
StatementClass *stmt;
ARDFields *ardopts;
- mylog("%s: entering...\n", func);
+ MYLOG(0, "%s: entering...\n", func);
if (!conn)
{
stmt = SC_Constructor(conn);
- mylog("**** PGAPI_AllocStmt: hdbc = %p, stmt = %p\n", hdbc, stmt);
+ MYLOG(0, "**** PGAPI_AllocStmt: hdbc = %p, stmt = %p\n", hdbc, stmt);
if (!stmt)
{
CSTR func = "PGAPI_FreeStmt";
StatementClass *stmt = (StatementClass *) hstmt;
- mylog("%s: entering...hstmt=%p, fOption=%hi\n", func, hstmt, fOption);
+ MYLOG(0, "%s: entering...hstmt=%p, fOption=%hi\n", func, hstmt, fOption);
if (!stmt)
{
CSTR func = "SC_Destructor";
QResultClass *res = SC_get_Result(self);
- mylog("SC_Destructor: self=%p, self->result=%p, self->hdbc=%p\n", self, res, self->hdbc);
+ MYLOG(0, "SC_Destructor: 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("SC_Destructor: EXIT\n");
+ MYLOG(0, "SC_Destructor: EXIT\n");
return TRUE;
}
{
self->result = self->curres = NULL;
self->curr_param_result = 0;
- mylog("SC_init_Result(%x)", self);
+ MYLOG(0, "SC_init_Result(%p)", self);
}
void
{
if (res != self->result)
{
- mylog("SC_set_Result(%x, %x)", self, res);
+ MYLOG(0, "SC_set_Result(%p, %p)", self, res);
QR_Destructor(self->result);
self->result = self->curres = res;
if (NULL != res)
QResultClass *res = SC_get_Curres(stmt);
SQLLEN incr = start - stmt->rowset_start;
-inolog("%p->SC_set_rowstart " FORMAT_LEN "->" FORMAT_LEN "(%s) ", stmt, stmt->rowset_start, start, valid_base ? "valid" : "unknown");
+MYLOG(1, "%p->SC_set_rowstart " FORMAT_LEN "->" FORMAT_LEN "(%s) ", stmt, stmt->rowset_start, start, valid_base ? "valid" : "unknown");
if (res != NULL)
{
BOOL valid = QR_has_valid_base(res);
-inolog(":(%p)QR is %s", res, QR_has_valid_base(res) ? "valid" : "unknown");
+MYLOG(1, ":(%p)QR is %s", res, QR_has_valid_base(res) ? "valid" : "unknown");
if (valid)
{
}
if (!QR_get_cursor(res))
res->key_base = start;
-inolog(":(%p)QR result=" FORMAT_LEN "(%s)", res, QR_get_rowstart_in_cache(res), QR_has_valid_base(res) ? "valid" : "unknown");
+MYLOG(1, ":(%p)QR result=" FORMAT_LEN "(%s)", res, QR_get_rowstart_in_cache(res), QR_has_valid_base(res) ? "valid" : "unknown");
}
stmt->rowset_start = start;
-inolog(":stmt result=" FORMAT_LEN "\n", stmt->rowset_start);
+MYLOG(1, ":stmt result=" FORMAT_LEN "\n", stmt->rowset_start);
}
void
SC_inc_rowset_start(StatementClass *stmt, SQLLEN inc)
*/
if (self->prepare && self->status == STMT_DESCRIBED)
{
- mylog("SC_opencheck: self->prepare && self->status == STMT_DESCRIBED\n");
+ MYLOG(0, "SC_opencheck: 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("%s: self= %p\n", func, self);
+ MYLOG(0, "%s: self= %p\n", func, self);
SC_clear_error(self);
/* This would not happen */
/* Free the parsed table/field information */
SC_initialize_cols_info(self, TRUE, TRUE);
-inolog("SC_clear_parse_status\n");
+MYLOG(1, "SC_clear_parse_status\n");
SC_clear_parse_status(self, conn);
break;
}
SC_set_rowset_start(self, -1, FALSE);
SC_set_current_col(self, -1);
self->bind_row = 0;
-inolog("%s statement=%p ommitted=0\n", func, self);
+MYLOG(1, "%s statement=%p ommitted=0\n", func, self);
self->last_fetch_count = self->last_fetch_count_include_ommitted = 0;
self->__error_message = NULL;
SQLSMALLINT num_p;
encoded_str encstr;
- mylog("%s: entering...\n", func);
+ MYLOG(0, "%s: entering...\n", func);
num_p = 0;
if (proc_return)
*proc_return = 0;
{
Int4 num_fields = -1;
QResultClass *res;
- mylog("SC_describe: status = %d\n", self->status);
+ MYLOG(0, "SC_describe: status = %d\n", self->status);
res = SC_get_Curres(self);
if (NULL != res)
}
if (self->status == STMT_READY)
{
-mylog(" preprocess: status = READY\n");
+MYLOG(0, " preprocess: status = READY\n");
self->miscinfo = 0;
self->execinfo = 0;
{
StatementClass *child = stmt, *parent;
-inolog("SC_get_ancestor in stmt=%p\n", stmt);
+MYLOG(1, "SC_get_ancestor in stmt=%p\n", stmt);
for (child = stmt, parent = child->execute_parent; parent; child = parent, parent = child->execute_parent)
{
- inolog("parent=%p\n", parent);
+ MYLOG(1, "parent=%p\n", parent);
}
return child;
}
QResultClass *self_res;
BOOL repstate;
-inolog("SC_set_error_from_res %p->%p check=%i\n", from_res ,self, check);
+MYLOG(1, "SC_set_error_from_res %p->%p check=%i\n", from_res ,self, check);
if (check)
{
if (0 == number) return;
QResultClass *self_res, *from_res;
BOOL repstate;
-inolog("SC_error_copy %p->%p check=%i\n", from ,self, check);
+MYLOG(1, "SC_error_copy %p->%p check=%i\n", from ,self, check);
if (self == from) return;
if (check)
{
{
PG_ErrorInfo *pgerror;
-inolog("SC_full_error_copy %p->%p\n", from ,self);
+MYLOG(1, "SC_full_error_copy %p->%p\n", from ,self);
if (self->__error_message)
{
free(self->__error_message);
/* TupleField *tupleField; */
-inolog("%s statement=%p res=%x ommitted=0\n", func, self, res);
+MYLOG(1, "%s statement=%p res=%p ommitted=0\n", func, self, res);
self->last_fetch_count = self->last_fetch_count_include_ommitted = 0;
if (!res)
return SQL_ERROR;
coli = QR_get_fields(res); /* the column info */
- mylog("fetch_cursor=%d, %p->total_read=%d\n", SC_is_fetchcursor(self), res, res->num_total_read);
+ MYLOG(0, "fetch_cursor=%d, %p->total_read=" FORMAT_LEN "\n", SC_is_fetchcursor(self), res, res->num_total_read);
useCursor = (SC_is_fetchcursor(self) && (NULL != QR_get_cursor(res)));
if (!useCursor)
return SQL_NO_DATA_FOUND;
}
- mylog("**** %s: non-cursor_result\n", func);
+ MYLOG(0, "**** %s: non-cursor_result\n", func);
(self->currTuple)++;
}
else
retval = QR_next_tuple(res, self);
if (retval < 0)
{
- mylog("**** %s: end_tuples\n", func);
+ MYLOG(0, "**** %s: end_tuples\n", func);
if (QR_get_cursor(res) &&
SQL_CURSOR_FORWARD_ONLY == self->options.cursor_type &&
QR_once_reached_eof(res))
if (kres_ridx >= 0 && kres_ridx < res->num_cached_keys)
{
UWORD pstatus = res->keyset[kres_ridx].status;
-inolog("SC_ pstatus[%d]=%hx fetch_count=" FORMAT_LEN "\n", kres_ridx, pstatus, self->last_fetch_count);
+MYLOG(1, "SC_ pstatus[" FORMAT_LEN "]=%hx fetch_count=" FORMAT_LEN "\n", kres_ridx, pstatus, self->last_fetch_count);
if (0 != (pstatus & (CURS_SELF_DELETING | CURS_SELF_DELETED)))
return SQL_SUCCESS_WITH_INFO;
if (SQL_ROW_DELETED != (pstatus & KEYSET_INFO_PUBLIC) &&
result = SQL_SUCCESS;
self->last_fetch_count++;
-inolog("%s: stmt=%p ommitted++\n", func, self);
+MYLOG(1, "%s: stmt=%p ommitted++\n", func, self);
self->last_fetch_count_include_ommitted++;
opts = SC_get_ARDF(self);
extend_getdata_info(gdata, opts->allocated, TRUE);
for (lf = 0; lf < num_cols; lf++)
{
- mylog("fetch: cols=%d, lf=%d, opts = %p, opts->bindings = %p, buffer[] = %p\n", num_cols, lf, opts, opts->bindings, opts->bindings[lf].buffer);
+ MYLOG(0, "fetch: cols=%d, lf=%d, opts = %p, opts->bindings = %p, buffer[] = %p\n", num_cols, lf, opts, opts->bindings, opts->bindings[lf].buffer);
/* reset for SQLGetData */
GETDATA_RESET(gdata->gdata[lf]);
type = CI_get_oid(coli, lf); /* speed things up */
atttypmod = CI_get_atttypmod(coli, lf); /* speed things up */
- mylog("type = %d, atttypmod = %d\n", type, atttypmod);
+ MYLOG(0, "type = %d, atttypmod = %d\n", type, atttypmod);
if (useCursor)
value = QR_get_value_backend(res, lf);
else
{
SQLLEN curt = GIdx2CacheIdx(self->currTuple, self, res);
-inolog("%p->base=%d curr=%d st=%d valid=%d\n", res, QR_get_rowstart_in_cache(res), self->currTuple, SC_get_rowset_start(self), QR_has_valid_base(res));
-inolog("curt=%d\n", curt);
+MYLOG(1, "%p->base=" FORMAT_LEN " curr=" FORMAT_LEN " st=" FORMAT_LEN " valid=%d\n", res, QR_get_rowstart_in_cache(res), self->currTuple, SC_get_rowset_start(self), QR_has_valid_base(res));
+MYLOG(1, "curt=" FORMAT_LEN "\n", curt);
value = QR_get_value_backend_row(res, curt, lf);
}
- mylog("value = '%s'\n", (value == NULL) ? "<NULL>" : value);
+ MYLOG(0, "value = '%s'\n", (value == NULL) ? "<NULL>" : value);
retval = copy_and_convert_field_bindinfo(self, type, atttypmod, value, lf);
- mylog("copy_and_convert: retval = %d\n", retval);
+ MYLOG(0, "copy_and_convert: retval = %d\n", retval);
switch (retval)
{
numcols;
QueryInfo qi;
ConnInfo *ci;
- UDWORD qflag = 0;
+ unsigned int qflag = 0;
BOOL is_in_trans, issue_begin, has_out_para;
BOOL use_extended_protocol;
int func_cs_count = 0, i;
if (CONN_EXECUTING == conn->status)
{
SC_set_error(self, STMT_SEQUENCE_ERROR, "Connection is already in use.", func);
- mylog("%s: problem with connection\n", func);
+ MYLOG(0, "%s: problem with connection\n", func);
goto cleanup;
}
is_in_trans = CC_is_in_trans(conn);
}
if (issue_begin)
{
- mylog(" about to begin a transaction on statement = %p\n", self);
+ MYLOG(0, " about to begin a transaction on statement = %p\n", self);
qflag |= GO_INTO_TRANSACTION;
}
QueryInfo *qryi = NULL;
qflag |= (SQL_CONCUR_READ_ONLY != self->options.scroll_concurrency ? CREATE_KEYSET : 0);
- mylog(" Sending SELECT statement on stmt=%p, cursor_name='%s' qflag=%d,%d\n", self, SC_cursor_name(self), qflag, self->options.scroll_concurrency);
+ MYLOG(0, " Sending SELECT statement on stmt=%p, cursor_name='%s' qflag=%d,%d\n", self, SC_cursor_name(self), qflag, self->options.scroll_concurrency);
/* send the declare/select */
if (useCursor)
if (res && SC_is_with_hold(self))
QR_set_withhold(res);
}
- mylog(" done sending the query:\n");
+ MYLOG(0, " done sending the query:\n");
}
else
{
/* not a SELECT statement so don't use a cursor */
- mylog(" it's NOT a select statement: stmt=%p\n", self);
+ MYLOG(0, " it's NOT a select statement: stmt=%p\n", self);
res = CC_send_query(conn, self->stmt_with_params, NULL, qflag, SC_get_ancestor(self));
}
}
}
-inolog("!!%p->miscinfo=%x res=%p\n", self, self->miscinfo, res);
+MYLOG(1, "!!%p->miscinfo=%x res=%p\n", self, self->miscinfo, res);
/*
* special handling of result for keyset driven cursors.
* Use the columns info of the 1st query and
*/
#ifdef REFCUR_SUPPORT
-inolog("!!! numfield=%d field_type=%u\n", QR_NumResultCols(res), QR_get_field_type(res, 0));
+MYLOG(1, "!!! numfield=%d field_type=%u\n", QR_NumResultCols(res), QR_get_field_type(res, 0));
if (!has_out_para &&
0 < QR_NumResultCols(res) &&
PG_TYPE_REFCURSOR == QR_get_field_type(res, 0))
self->bind_row = 0;
ret = SC_fetch(hstmt);
-inolog("!!SC_fetch return =%d\n", ret);
+MYLOG(1, "!!SC_fetch return =%d\n", ret);
if (SQL_SUCCEEDED(ret))
{
APDFields *apdopts = SC_get_APDF(self);
stmt->callbacks[stmt->num_callbacks].data = data;
stmt->num_callbacks++;
-inolog("enqueueNeedDataCallack stmt=%p, func=%p, count=%d\n", stmt, func, stmt->num_callbacks);
+MYLOG(1, "enqueueNeedDataCallack stmt=%p, func=%p, count=%d\n", stmt, func, stmt->num_callbacks);
return stmt->num_callbacks;
}
void *data;
int i, cnt;
- mylog("dequeueNeedDataCallback ret=%d count=%d\n", retcode, stmt->num_callbacks);
+ MYLOG(0, "dequeueNeedDataCallback ret=%d count=%d\n", retcode, stmt->num_callbacks);
if (SQL_NEED_DATA == retcode)
return retcode;
if (stmt->num_callbacks <= 0)
head = "STATEMENT ERROR";
qlog("%s: func=%s, desc='%s', errnum=%d, errmsg='%s'\n",head, func, desc, self->__error_number, NULLCHECK(self->__error_message));
}
- mylog("%s: func=%s, desc='%s', errnum=%d, errmsg='%s'\n", head, func, desc, self->__error_number, NULLCHECK(self->__error_message));
+ MYLOG(0, "%s: func=%s, desc='%s', errnum=%d, errmsg='%s'\n", head, func, desc, self->__error_number, NULLCHECK(self->__error_message));
if (SC_get_errornumber(self) > 0)
{
qlog(" ------------------------------------------------------------\n");
else
{
qlog("INVALID STATEMENT HANDLE ERROR: func=%s, desc='%s'\n", func, desc);
- mylog("INVALID STATEMENT HANDLE ERROR: func=%s, desc='%s'\n", func, desc);
+ MYLOG(0, "INVALID STATEMENT HANDLE ERROR: func=%s, desc='%s'\n", func, desc);
}
}
#endif /* NOT_USED */
/* 1. Bind */
- mylog("%s: bind stmt=%p\n", func, stmt);
+ MYLOG(0, "%s: bind stmt=%p\n", func, stmt);
if (!build_libpq_bind_params(stmt,
&nParams,
¶mTypes,
}
/* 2. Execute */
- mylog("%s: execute stmt=%p\n", func, stmt);
+ MYLOG(0, "%s: execute stmt=%p\n", func, stmt);
if (!SC_is_fetchcursor(stmt))
{
if (stmt->prepared == NOT_YET_PREPARED ||
}
pstmt = stmt->processed_statements;
- mylog("%s execParams query=%s nParams=%d\n", __FUNCTION__, pstmt->query, nParams);
+ MYLOG(0, "%s execParams query=%s nParams=%d\n", __FUNCTION__, pstmt->query, nParams);
pgres = PQexecParams(conn->pqconn,
pstmt->query,
nParams,
plan_name = stmt->plan_name ? stmt->plan_name : NULL_STRING;
/* already prepared */
- mylog("%s execPrepared plan=%s nParams=%d\n", __FUNCTION__, plan_name, nParams);
+ MYLOG(0, "%s execPrepared plan=%s nParams=%d\n", __FUNCTION__, plan_name, nParams);
pgres = PQexecPrepared(conn->pqconn,
plan_name, /* portal name == plan name */
nParams,
}
/* 3. Receive results */
-inolog("get_Result=%p %p %d\n", res, SC_get_Result(stmt), stmt->curr_param_result);
+MYLOG(1, "get_Result=%p %p %d\n", res, SC_get_Result(stmt), stmt->curr_param_result);
pgresstatus = PQresultStatus(pgres);
switch (pgresstatus)
{
/* portal query command, no tuples returned */
/* read in the return message from the backend */
cmdtag = PQcmdStatus(pgres);
- mylog("command response: %s\n", cmdtag);
+ MYLOG(0, "command response: %s\n", cmdtag);
QR_set_command(res, cmdtag);
if (QR_command_successful(res))
QR_set_rstatus(res, PORES_COMMAND_OK);
CC_set_error(conn, CONNECTION_BACKEND_CRAZY, "Unexpected protocol character from backend (send_query)", func);
CC_on_abort(conn, CONN_DEAD);
- mylog("send_query: error - %s\n", CC_get_errormsg(conn));
+ MYLOG(0, "send_query: error - %s\n", CC_get_errormsg(conn));
break;
}
BOOL retval = FALSE;
PGresult *pgres = NULL;
- mylog("%s: plan_name=%s query=%s\n", func, plan_name, query);
+ MYLOG(0, "%s: plan_name=%s query=%s\n", func, plan_name, query);
qlog("%s: plan_name=%s query=%s\n", func, plan_name, query);
if (!RequestStart(stmt, conn, func))
return FALSE;
break;
}
}
-mylog("sta_pidx=%d end_pidx=%d num_p=%d\n", sta_pidx, end_pidx, num_params);
+MYLOG(0, "sta_pidx=%d end_pidx=%d num_p=%d\n", sta_pidx, end_pidx, num_params);
}
/*
goto cleanup;
}
- mylog("ipdopts->allocated: %d\n", ipdopts->allocated);
+ MYLOG(0, "ipdopts->allocated: %d\n", ipdopts->allocated);
j = 0;
for (i = sta_pidx; i <= end_pidx; i++)
{
handle_pgres_error(conn, pgres, "ParseWithlibpq", res, TRUE);
goto cleanup;
}
-mylog("PQprepare was successful, plan=%s\n", plan_name ? plan_name : "");
+MYLOG(0, "PQprepare was successful, plan=%s\n", plan_name ? plan_name : "");
if (stmt->plan_name)
SC_set_prepared(stmt, PREPARED_PERMANENTLY);
else
Oid oid;
SQLSMALLINT paramType;
- mylog("%s: plan_name=%s query=%s\n", func, plan_name, query_param);
+ MYLOG(0, "%s: plan_name=%s query=%s\n", func, plan_name, query_param);
qlog("%s: plan_name=%s query=%s\n", func, plan_name, query_param);
if (!RequestStart(stmt, conn, func))
return NULL;
goto cleanup;
/* Describe */
- mylog("%s: describing plan_name=%s\n", func, plan_name);
+ MYLOG(0, "%s: describing plan_name=%s\n", func, plan_name);
pgres = PQdescribePrepared(conn->pqconn, plan_name);
switch (PQresultStatus(pgres))
CC_set_error(conn, CONNECTION_BACKEND_CRAZY, "Unexpected result from PQdescribePrepared", func);
CC_on_abort(conn, CONN_DEAD);
- mylog("send_query: error - %s\n", CC_get_errormsg(conn));
+ MYLOG(0, "send_query: error - %s\n", CC_get_errormsg(conn));
goto cleanup;
}
/* Extract parameter information from the result set */
num_p = PQnparams(pgres);
-inolog("num_params=%d info=%d\n", stmt->num_params, num_p);
+MYLOG(1, "num_params=%d info=%d\n", stmt->num_params, num_p);
num_discard_params = 0;
if (stmt->discard_output_params)
CountParameters(stmt, NULL, NULL, &num_discard_params);
num_discard_params = stmt->proc_return;
if (num_p + num_discard_params != (int) stmt->num_params)
{
- mylog("ParamInfo unmatch num_params(=%d) != info(=%d)+discard(=%d)\n", stmt->num_params, num_p, num_discard_params);
+ MYLOG(0, "ParamInfo unmatch num_params(=%d) != info(=%d)+discard(=%d)\n", stmt->num_params, num_p, num_discard_params);
/* stmt->num_params = (Int2) num_p + num_discard_params; it's possible in case of multi command queries */
}
ipdopts = SC_get_IPDF(stmt);
SC_param_next(stmt, &pidx, NULL, NULL);
if (pidx >= stmt->num_params)
{
- mylog("%dth parameter's position(%d) is out of bound[%d]\n", i, pidx, stmt->num_params);
+ MYLOG(0, "%dth parameter's position(%d) is out of bound[%d]\n", i, pidx, stmt->num_params);
break;
}
oid = PQparamtype(pgres, i);
if (SQL_PARAM_OUTPUT == paramType ||
SQL_PARAM_INPUT_OUTPUT == paramType)
{
- inolog("!![%d].PGType %u->%u\n", i, PIC_get_pgtype(ipdopts->parameters[i]), CI_get_oid(QR_get_fields(res), cidx));
+ MYLOG(1, "!![%d].PGType %u->%u\n", i, PIC_get_pgtype(ipdopts->parameters[i]), CI_get_oid(QR_get_fields(res), cidx));
PIC_set_pgtype(ipdopts->parameters[i], CI_get_oid(QR_get_fields(res), cidx));
cidx++;
}
cpylen = sizeof(pg_bm);
else if (*used >= 12)
cpylen = 12;
- mylog("%s used=%d cpylen=%d\n", __FUNCTION__, *used, cpylen);
+ MYLOG(0, "%s used=" FORMAT_LEN " cpylen=" FORMAT_SIZE_T "\n", __FUNCTION__, *used, cpylen);
}
memcpy(&pg_bm, CALC_BOOKMARK_ADDR(bookmark, offset, bind_size, idx), cpylen);
-mylog("%s index=%d block=%d off=%d\n", __FUNCTION__, pg_bm.index, pg_bm.keys.blocknum, pg_bm.keys.offset);
+MYLOG(0, "%s index=%d block=%d off=%d\n", __FUNCTION__, 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("%s type=%d buflen=%d buf=%p\n", __FUNCTION__, bookmark->returntype, bookmark->buflen, bookmark->buffer);
+MYLOG(0, "%s type=%d buflen=" FORMAT_LEN " buf=%p\n", __FUNCTION__, 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("%s cvtlen=%d ix(bl,of)=%d(%d,%d)\n", __FUNCTION__, cvtlen, pg_bm.index, pg_bm.keys.blocknum, pg_bm.keys.offset);
+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);
return COPY_OK;
}
'\0' == cdt[2] &&
'\0' == cdt[3])
{
- mylog(" %s:UTF-16LE detected\n", __FUNCTION__);
+ MYLOG(0, " %s:UTF-16LE detected\n", __FUNCTION__);
convtype = WCSTYPE_UTF16_LE;
use_wcs = TRUE;
}
'\0' == cdt[6] &&
'\0' == cdt[7])
{
- mylog(" %s:UTF32-LE detected\n", __FUNCTION__);
+ MYLOG(0, " %s:UTF32-LE detected\n", __FUNCTION__);
convtype = WCSTYPE_UTF32_LE;
use_wcs = TRUE;
}
'\0' == cdt[2] &&
'\0' == cdt[3])
{
- mylog(" %s:C16_UTF-16LE detected\n", __FUNCTION__);
+ MYLOG(0, " %s:C16_UTF-16LE detected\n", __FUNCTION__);
convtype = C16TYPE_UTF16_LE;
use_c16 = TRUE;
}
{
char * utf8str;
int len = 0;
-/*mylog("ucs2_to_utf8 %p ilen=%d ", ucs2str, ilen);*/
+/*MYLOG(0, "ucs2_to_utf8 %p ilen=%d ", ucs2str, ilen);*/
if (!ucs2str)
{
}
if (ilen < 0)
ilen = ucs2strlen(ucs2str);
-mylog(" newlen=%d", ilen);
+MYLOG(0, " newlen=" FORMAT_LEN, ilen);
utf8str = (char *) malloc(ilen * 4 + 1);
if (utf8str)
{
if (olen)
*olen = len;
}
-mylog(" %s:olen=%d utf8str=%s\n", __FUNCTION__, len, utf8str ? utf8str : "");
+MYLOG(0, " %s:olen=%d utf8str=%s\n", __FUNCTION__, len, utf8str ? utf8str : "");
return utf8str;
}
SQLULEN rtn, ocount, wcode;
const UCHAR *str;
-/*mylog("utf8_to_ucs2 ilen=%d bufcount=%d", ilen, bufcount);*/
+/*MYLOG(0, "utf8_to_ucs2 ilen=%d bufcount=%d", ilen, bufcount);*/
if (!utf8str)
return 0;
-/*mylog(" string=%s\n", utf8str);*/
+/*MYLOG(0, " string=%s\n", utf8str);*/
if (!bufcount)
ucs2str = NULL;
}
if (ocount < bufcount && ucs2str)
ucs2str[ocount] = 0;
-/*mylog(" ocount=%d\n", ocount);*/
+/*MYLOG(0, " ocount=%d\n", ocount);*/
return rtn;
}
{
char * utf8str;
int len = 0;
-mylog(" %s:%p ilen=%d\n", __FUNCTION__, ucs4str, ilen);
+MYLOG(0, " %s:%p ilen=" FORMAT_LEN "\n", __FUNCTION__, ucs4str, ilen);
if (!ucs4str)
{
}
if (ilen < 0)
ilen = ucs4strlen(ucs4str);
-mylog(" newlen=%d\n", ilen);
+MYLOG(0, " newlen=" FORMAT_LEN "\n", ilen);
utf8str = (char *) malloc(ilen * 4 + 1);
if (utf8str)
{
((byte4_mask2 & *wstr) >> 4) |
((byte4_mask3 & *wstr) << 10) |
((byte4_mask4 & *wstr) << 24);
-/* mylog(" %s:%08x->%08x\n", __FUNCTION__, *wstr, byte4code); */
+/* MYLOG(0, " %s:%08x->%08x\n", __FUNCTION__, *wstr, byte4code); */
if (little_endian)
memcpy(utf8str + len, (char *) &byte4code, sizeof(byte4code));
else
if (olen)
*olen = len;
}
-mylog(" %s:olen=%d %s\n", __FUNCTION__, len, utf8str ? utf8str : "");
+MYLOG(0, " %s:olen=%d %s\n", __FUNCTION__, len, utf8str ? utf8str : "");
return utf8str;
}
SQLULEN rtn, ocount, wcode;
const UCHAR *str;
-mylog(" %s:ilen=%d bufcount=%d\n", __FUNCTION__, ilen, bufcount);
+MYLOG(0, " %s:ilen=" FORMAT_LEN " bufcount=" FORMAT_ULEN "\n", __FUNCTION__, ilen, bufcount);
if (!utf8str)
return 0;
-/*mylog(" string=%s\n", utf8str);*/
+/*MYLOG(0, " string=%s\n", utf8str);*/
if (!bufcount)
ucs4str = NULL;
}
if (ocount < bufcount && ucs4str)
ucs4str[ocount] = 0;
-mylog(" %s:ocount=%d\n", __FUNCTION__, ocount);
+MYLOG(0, " %s:ocount=" FORMAT_ULEN "\n", __FUNCTION__, ocount);
return rtn;
}
UCHAR * const udt = (UCHAR *) &dmy_wchar;
unsigned int uintdt;
-mylog(" %s:ilen=%d bufcount=%d\n", __FUNCTION__, ilen, bufcount);
+MYLOG(0, " %s:ilen=" FORMAT_LEN " bufcount=%d\n", __FUNCTION__, 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(" %s:ilen=%d bufcount=%d\n", __FUNCTION__, ilen, bufcount);
+MYLOG(0, " %s:ilen=" FORMAT_LEN " bufcount=%d\n", __FUNCTION__, ilen, bufcount);
if (ilen < 0)
ilen = ucs2strlen(ucs2str);
udt[3] = 0; /* always */
{
int outlen = -1;
-mylog(" %s:inmsg=%p buflen=%d\n", __FUNCTION__, inmsg, buflen);
+MYLOG(0, " %s:inmsg=%p buflen=%d\n", __FUNCTION__, inmsg, buflen);
#ifdef WIN32
if (NULL == outmsg)
buflen = 0;
if (outmsg && outlen >= buflen)
{
outmsg[buflen - 1] = 0;
- mylog(" %s:out=%dchars truncated to %d\n", __FUNCTION__, outlen, buflen - 1);
+ MYLOG(0, " %s:out=%dchars truncated to %d\n", __FUNCTION__, outlen, buflen - 1);
}
-mylog(" %s buf=%dchars out=%dchars\n", __FUNCTION__, buflen, outlen);
+MYLOG(0, " %s buf=%dchars out=%dchars\n", __FUNCTION__, buflen, outlen);
return outlen;
}
{
int outlen = -1;
-mylog(" %s:wstr=%p buflen=%d\n", __FUNCTION__, wstr, buflen);
+MYLOG(0, " %s:wstr=%p buflen=%d\n", __FUNCTION__, wstr, buflen);
#ifdef WIN32
if (NULL == outmsg)
buflen = 0;
if (outmsg && outlen >= buflen)
{
outmsg[buflen - 1] = 0;
- mylog(" %s:out=%dbytes truncated to %d\n", __FUNCTION__, outlen, buflen - 1);
+ MYLOG(0, " %s:out=%dbytes truncated to %d\n", __FUNCTION__, outlen, buflen - 1);
}
-mylog(" %s buf=%dbytes outlen=%dbytes\n", __FUNCTION__, buflen, outlen);
+MYLOG(0, " %s buf=%dbytes outlen=%dbytes\n", __FUNCTION__, buflen, outlen);
return outlen;
}
const char *cdt;
mbstate_t mbst = initial_state;
-mylog(" %s:c16dt=%p size=%lu\n", __FUNCTION__, c16dt, n);
+MYLOG(0, " %s:c16dt=%p size=%lu\n", __FUNCTION__, 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(" %s:c8dt=%p size=%lu\n", __FUNCTION__, c8dt, n);
+MYLOG(0, " %s:c8dt=%p size=%lu\n", __FUNCTION__, c8dt, n);
if (!c8dt)
n = 0;
for (i = 0, cdt = c8dt; c16dt[i] && (result < n || (!cdt)); i++)
}
get_convtype();
- mylog(" %s\n", __FUNCTION__);
+ MYLOG(0, " %s\n", __FUNCTION__);
#if defined(__WCS_ISO10646__)
if (use_wcs)
{
}
get_convtype();
-mylog(" %s\n", __FUNCTION__);
+MYLOG(0, " %s\n", __FUNCTION__);
#if defined(__WCS_ISO10646__)
if (use_wcs)
{
SQLLEN l = (-2);
get_convtype();
- mylog(" %s:lf_conv=%d\n", __FUNCTION__, lf_conv);
+ MYLOG(0, " %s:lf_conv=%d\n", __FUNCTION__, lf_conv);
#if defined(__WCS_ISO10646__)
if (use_wcs)
{
SQLLEN l = (-2);
get_convtype();
- mylog(" %s:size=" FORMAT_SIZE_T " lf_conv=%d\n", __FUNCTION__, n, lf_conv);
+ MYLOG(0, " %s:size=" FORMAT_SIZE_T " lf_conv=%d\n", __FUNCTION__, n, lf_conv);
#if defined(__WCS_ISO10646__)
if (use_wcs)
{
char *convalc = NULL;
get_convtype();
- mylog(" %s:lf_conv=%d\n", __FUNCTION__, lf_conv);
+ MYLOG(0, " %s:lf_conv=%d\n", __FUNCTION__, lf_conv);
#if defined(__WCS_ISO10646__)
if (use_wcs)
{
else if (NULL != convalc)
*wcsbuf = (char *) convalc;
-mylog(" %s:return=%d\n", __FUNCTION__, l);
+MYLOG(0, " %s:return=" FORMAT_LEN "\n", __FUNCTION__, l);
return l;
}
SQLLEN l = (-2);
get_convtype();
- mylog(" %s:size=" FORMAT_SIZE_T "\n", __FUNCTION__, n);
+ MYLOG(0, " %s:size=" FORMAT_SIZE_T "\n", __FUNCTION__, n);
#if defined(__WCS_ISO10646__)
if (use_wcs)
{
free(*wcsbuf);
*wcsbuf = NULL;
-mylog(" %s:return=%d\n", __FUNCTION__, l);
+MYLOG(0, " %s:return=" FORMAT_LEN "\n", __FUNCTION__, l);
return l;
}
projects / psqlodbc.git / commitdiff