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=%x, pcbValue = %x(%d), data_at_exec = %d\n", rgbValue, pcbValue, pcbValue ? *pcbValue : -777, apdopts->parameters[ipar].data_at_exec); ***/
+ /*** mylog("rgbValue=%p, pcbValue = %p(%d), data_at_exec = %d\n", rgbValue, pcbValue, pcbValue ? *pcbValue : -777, apdopts->parameters[ipar].data_at_exec); ***/
- mylog("rgbValue=%x, pcbValue = %x, data_at_exec = %d\n", rgbValue, pcbValue, apdopts->parameters[ipar].data_at_exec);
+ mylog("rgbValue=%p, pcbValue = %p, data_at_exec = %d\n", rgbValue, pcbValue, apdopts->parameters[ipar].data_at_exec);
return SQL_SUCCESS;
}
mylog("%s: entering...\n", func);
- mylog("**** PGAPI_BindCol: stmt = %x, icol = %d\n", stmt, icol);
- mylog("**** : fCType=%d rgb=%x valusMax=%d pcb=%x\n", fCType, rgbValue, cbValueMax, pcbValue);
+ mylog("**** PGAPI_BindCol: stmt = %p, icol = %d\n", stmt, icol);
+ mylog("**** : fCType=%d rgb=%p valusMax=%d pcb=%p\n", fCType, rgbValue, cbValueMax, pcbValue);
if (!stmt)
{
opts->bindings[icol].precision = 0;
opts->bindings[icol].scale = 0;
- mylog(" bound buffer[%d] = %x\n", icol, opts->bindings[icol].buffer);
+ mylog(" bound buffer[%d] = %p\n", icol, opts->bindings[icol].buffer);
}
cleanup:
APDFields *apdopts;
IPDFields *ipdopts;
- mylog("%s: entering... %d %x\n", func, crow, pirow);
+ mylog("%s: entering... %d %p\n", func, crow, pirow);
apdopts = SC_get_APDF(stmt);
apdopts->paramset_size = crow;
CSTR func = "extend_parameter_bindings";
ParameterInfoClass *new_bindings;
- mylog("%s: entering ... self=%x, parameters_allocated=%d, num_params=%d\n", func, self, self->allocated, num_params);
+ mylog("%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
CSTR func = "extend_iparameter_bindings";
ParameterImplClass *new_bindings;
- mylog("%s: entering ... self=%x, parameters_allocated=%d, num_params=%d\n", func, self, self->allocated, num_params);
+ mylog("%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
{
CSTR func = "reset_a_parameter_binding";
- mylog("%s: entering ... self=%x, parameters_allocated=%d, ipar=%d\n", func, self, self->allocated, ipar);
+ mylog("%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=%x, parameters_allocated=%d, ipar=%d\n", func, self, self->allocated, ipar);
+ mylog("%s: entering ... self=%p, parameters_allocated=%d, ipar=%d\n", func, self, self->allocated, ipar);
if (ipar < 1 || ipar > self->allocated)
return;
{
int i;
- mylog("PDATA_free_params: ENTER, self=%x\n", pdata);
+ mylog("PDATA_free_params: ENTER, self=%p\n", pdata);
if (!pdata->pdata)
return;
void
IPD_free_params(IPDFields *ipdopts, char option)
{
- mylog("IPD_free_params: ENTER, self=%x\n", ipdopts);
+ mylog("IPD_free_params: ENTER, self=%p\n", ipdopts);
if (!ipdopts->parameters)
return;
BindInfoClass *new_bindings;
int i;
- mylog("%s: entering ... self=%x, bindings_allocated=%d, num_columns=%d\n", func, self, self->allocated, num_columns);
+ mylog("%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
CSTR func = "reset_a_column_binding";
BindInfoClass *bookmark;
- mylog("%s: entering ... self=%x, bindings_allocated=%d, icol=%d\n", func, self, self->allocated, icol);
+ mylog("%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=%x", freeall, self->allocated, self->bindings);
+inolog("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=%x", freeall, self->allocated, self->gdata);
+inolog("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=%x, gdata_allocated=%d, num_columns=%d\n", func, self, self->allocated, num_columns);
+ mylog("%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
CSTR func = "extend_putdata_info";
PutDataClass *new_pdata;
- mylog("%s: entering ... self=%x, parameters_allocated=%d, num_params=%d\n", func, self, self->allocated, num_params);
+ mylog("%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
mylog("%s: entering...\n", func);
conn = CC_Constructor();
- mylog("**** %s: henv = %x, conn = %x\n", func, henv, conn);
+ mylog("**** %s: henv = %p, conn = %p\n", func, henv, conn);
if (!conn)
{
ConnInfo *ci;
CSTR func = "PGAPI_Connect";
RETCODE ret = SQL_SUCCESS;
+ char fchar;
mylog("%s: entering...\n", func);
* override values from DSN info with UID and authStr(pwd) This only
* occurs if the values are actually there.
*/
+ fchar = ci->username[0]; /* save the first byte */
make_string(szUID, cbUID, ci->username, sizeof(ci->username));
+ if ('\0' == ci->username[0]) /* an empty string is specified */
+ ci->username[0] = fchar; /* restore the original username */
+ fchar = ci->password[0];
make_string(szAuthStr, cbAuthStr, ci->password, sizeof(ci->password));
+ if ('\0' == ci->password[0]) /* an empty string is specified */
+ ci->password[0] = fchar; /* restore the original password */
/* fill in any defaults */
getDSNdefaults(ci);
- qlog("conn = %x, %s(DSN='%s', UID='%s', PWD='%s')\n", conn, func, ci->dsn, ci->username, ci->password ? "xxxxx" : "");
+ qlog("conn = %p, %s(DSN='%s', UID='%s', PWD='%s')\n", conn, func, ci->dsn, ci->username, ci->password ? "xxxxx" : "");
if (CC_connect(conn, AUTH_REQ_OK, NULL) <= 0)
{
return SQL_INVALID_HANDLE;
}
- qlog("conn=%x, %s\n", conn, func);
+ qlog("conn=%p, %s\n", conn, func);
if (conn->status == CONN_EXECUTING)
{
CSTR func = "PGAPI_FreeConnect";
mylog("%s: entering...\n", func);
- mylog("**** in %s: hdbc=%x\n", func, hdbc);
+ mylog("**** in %s: hdbc=%p\n", func, hdbc);
if (!conn)
{
char
CC_Destructor(ConnectionClass *self)
{
- mylog("enter CC_Destructor, self=%x\n", self);
+ mylog("enter CC_Destructor, self=%p\n", self);
if (self->status == CONN_EXECUTING)
return 0;
count = 0;
QResultClass *res;
- mylog("CC_cursor_count: self=%x, num_stmts=%d\n", self, self->num_stmts);
+ mylog("CC_cursor_count: self=%p, num_stmts=%d\n", self, self->num_stmts);
CONNLOCK_ACQUIRE(self);
for (i = 0; i < self->num_stmts; i++)
if (self->status == CONN_EXECUTING)
return FALSE;
- mylog("in CC_Cleanup, self=%x\n", self);
+ mylog("in CC_Cleanup, self=%p\n", self);
/* Cancel an ongoing transaction */
/* We are always in the middle of a transaction, */
char tmout[16];
slen += (strlen(l_login_timeout) + 2 + 2);
- snprintf(tmout, sizeof(tmout), "%lu", self->login_timeout);
+ snprintf(tmout, sizeof(tmout), FORMAT_UINTEGER, self->login_timeout);
slen += strlen(tmout);
}
slen++;
{
sprintf(ppacket, " %s=", l_login_timeout);
ppacket += (strlen(l_login_timeout) + 2);
- sprintf(ppacket, "%lu", self->login_timeout);
+ sprintf(ppacket, FORMAT_UINTEGER, self->login_timeout);
ppacket = strchr(ppacket, '\0');
}
*ppacket = '\0';
int i;
char ret = TRUE;
- mylog("CC_add_statement: self=%x, stmt=%x\n", self, stmt);
+ mylog("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=%x\n", self);
+ mylog("CC_error_statements: self=%p\n", self);
for (i = 0; i < self->num_stmts; i++)
{
/* QR_set_command() dups this string so doesn't need static */
char cmdbuffer[ERROR_MSG_LENGTH + 1];
- mylog("send_query(): conn=%x, query='%s'\n", self, query);
- qlog("conn=%x, query='%s'\n", self, query);
+ mylog("send_query(): conn=%p, query='%s'\n", self, query);
+ qlog("conn=%p, query='%s'\n", self, query);
if (!self->sock)
{
QR_set_rstatus(res, PORES_COMMAND_OK);
QR_set_command(res, cmdbuffer);
query_completed = TRUE;
- mylog("send_query: returning res = %x\n", res);
+ mylog("send_query: returning res = %p\n", res);
if (!before_64)
break;
if (stmt)
res->num_key_fields = stmt->num_key_fields;
}
- mylog("send_query: 'T' no result_in: res = %x\n", res->next);
+ mylog("send_query: 'T' no result_in: res = %p\n", res->next);
res = res->next;
if (qi)
ConnInfo *ci;
int func_cs_count = 0;
- mylog("send_function(): conn=%x, fnid=%d, result_is_int=%d, nargs=%d\n", self, fnid, result_is_int, nargs);
+ mylog("send_function(): conn=%p, fnid=%d, result_is_int=%d, nargs=%d\n", self, fnid, result_is_int, nargs);
if (!self->sock)
{
for (i = 0; i < nargs; ++i)
{
- mylog(" arg[%d]: len = %d, isint = %d, integer = %d, ptr = %x\n", i, args[i].len, args[i].isint, args[i].u.integer, args[i].u.ptr);
+ mylog(" arg[%d]: len = %d, isint = %d, integer = %d, ptr = %p\n", i, args[i].len, args[i].isint, args[i].u.integer, args[i].u.ptr);
SOCK_put_int(sock, args[i].len, 4);
if (args[i].isint)
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));
qlog(" ------------------------------------------------------------\n");
- qlog(" henv=%x, conn=%x, status=%u, num_stmts=%d\n", self->henv, self, self->status, self->num_stmts);
- qlog(" sock=%x, stmts=%x, lobj_type=%d\n", self->sock, self->stmts, self->lobj_type);
+ qlog(" henv=%p, conn=%p, status=%u, num_stmts=%d\n", self->henv, self, self->status, self->num_stmts);
+ qlog(" sock=%p, stmts=%p, lobj_type=%d\n", self->sock, self->stmts, self->lobj_type);
qlog(" ---------------- Socket Info -------------------------------\n");
if (self->sock)
mylog("connecting to the database using %s as the server\n",self->connInfo.server);
sock = self->sock;
-inolog("sock=%x\n", sock);
+inolog("sock=%p\n", sock);
if (!sock)
{
sock = SOCK_Constructor(self);
{ \
if (pthread_mutex_lock(&((x)->cs)) == 0) \
entered++; \
- else \
- -1; \
} \
- else \
- 0; \
} while (0)
#define LEAVE_CONN_CS(x) pthread_mutex_unlock(&((x)->cs))
#define CONNLOCK_RELEASE(x) pthread_mutex_unlock(&((x)->slock))
}
}
-inolog("ipara=%x paramType=%d %d proc_return=%d\n", ipara, ipara ? ipara->paramType : -1, PG_VERSION_LT(conn, 8.1), qb->proc_return);
+inolog("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)
case SQL_C_SLONG:
case SQL_C_LONG:
- sprintf(param_string, "%ld",
+ sprintf(param_string, FORMAT_INTEGER,
*((SQLINTEGER *) buffer));
break;
break;
case SQL_C_ULONG:
- sprintf(param_string, "%lu",
+ sprintf(param_string, FORMAT_UINTEGER,
*((SQLUINTEGER *) buffer));
break;
*/
/* Special handling NULL string For FOXPRO */
-mylog("cvt_null_date_string=%d pgtype=%d buf=%x\n", conn->connInfo.cvt_null_date_string, param_pgtype, buf);
+mylog("cvt_null_date_string=%d pgtype=%d buf=%p\n", conn->connInfo.cvt_null_date_string, param_pgtype, buf);
if (conn->connInfo.cvt_null_date_string > 0 &&
PG_TYPE_DATE == param_pgtype &&
SQL_C_CHAR == param_ctype &&
static void ARDFields_free(ARDFields * self)
{
-inolog("ARDFields_free %x bookmark=%x", self, self->bookmark);
+inolog("ARDFields_free %p bookmark=%p", self, self->bookmark);
if (self->bookmark)
{
free(self->bookmark);
{
int i;
- mylog("CC_add_descriptor: self=%x, desc=%x\n", self, desc);
+ mylog("CC_add_descriptor: self=%p, desc=%p\n", self, desc);
for (i = 0; i < self->num_descs; i++)
{
switch (src->desc_type)
{
case SQL_ATTR_APP_ROW_DESC:
-inolog("src=%x target=%x type=%d", src, target, src->desc_type);
+inolog("src=%p target=%p type=%d", src, target, src->desc_type);
if (!target->type_defined)
{
target->desc_type = src->desc_type;
}
ard_src = (ARDFields *) (src + 1);
-inolog(" rowset_size=%d bind_size=%d ope_ptr=%x off_ptr=%x\n",
+inolog(" rowset_size=%d 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 = (ARDFields *) (target + 1);
-inolog(" target=%x", ard_tgt);
+inolog(" target=%p", ard_tgt);
ARDFields_copy(ard_src, ard_tgt);
-inolog(" offset_ptr=%x\n", ard_tgt->row_offset_ptr);
+inolog(" offset_ptr=%p\n", ard_tgt->row_offset_ptr);
break;
case SQL_ATTR_APP_PARAM_DESC:
if (!target->type_defined)
*/
/* Multibyte support Eiji Tokuya 2001-03-15 */
+#include <ctype.h>
#include "dlg_specific.h"
#include "convert.h"
#ifdef FORCE_PASSWORD_DISPLAY
mylog("**** PGAPI_DriverConnect: fDriverCompletion=%d, connStrIn='%s'\n", fDriverCompletion, connStrIn);
- qlog("conn=%x, PGAPI_DriverConnect( in)='%s', fDriverCompletion=%d\n", conn, connStrIn, fDriverCompletion);
+ 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));
- qlog("conn=%x, PGAPI_DriverConnect( in)='%s', fDriverCompletion=%d\n", conn, NULL_IF_NULL(hide_str), fDriverCompletion);
+ qlog("conn=%p, PGAPI_DriverConnect( in)='%s', fDriverCompletion=%d\n", conn, NULL_IF_NULL(hide_str), fDriverCompletion);
if (hide_str)
free(hide_str);
}
if (cbConnStrOutMax > 0)
{
mylog("szConnStrOut = '%s' len=%d,%d\n", NULL_IF_NULL(szConnStrOut), len, cbConnStrOutMax);
- qlog("conn=%x, PGAPI_DriverConnect(out)='%s'\n", conn, NULL_IF_NULL(szConnStrOut));
+ qlog("conn=%p, PGAPI_DriverConnect(out)='%s'\n", conn, NULL_IF_NULL(szConnStrOut));
}
#else
if (get_qlog() || get_mylog())
if (cbConnStrOutMax > 0)
hide_str = hide_password(szConnStrOut);
mylog("szConnStrOut = '%s' len=%d,%d\n", NULL_IF_NULL(hide_str), len, cbConnStrOutMax);
- qlog("conn=%x, PGAPI_DriverConnect(out)='%s'\n", conn, NULL_IF_NULL(hide_str));
+ qlog("conn=%p, PGAPI_DriverConnect(out)='%s'\n", conn, NULL_IF_NULL(hide_str));
if (hide_str)
free(hide_str);
}
{
LRESULT dialog_result;
- mylog("dconn_DoDialog: ci = %x\n", ci);
+ mylog("dconn_DoDialog: ci = %p\n", ci);
if (hwnd)
{
return SQL_ERROR;
}
- mylog("** exit PGAPI_AllocEnv: phenv = %x **\n", *phenv);
+ mylog("** exit PGAPI_AllocEnv: phenv = %p **\n", *phenv);
return SQL_SUCCESS;
}
CSTR func = "PGAPI_FreeEnv";
EnvironmentClass *env = (EnvironmentClass *) henv;
- mylog("**** in PGAPI_FreeEnv: env = %x ** \n", env);
+ mylog("**** in PGAPI_FreeEnv: env = %p ** \n", env);
if (env && EN_Destructor(env))
{
BOOL once_again = FALSE;
ssize_t msglen;
- mylog("**** PGAPI_ConnectError: hdbc=%x <%d>\n", hdbc, cbErrorMsgMax);
+ mylog("**** PGAPI_ConnectError: hdbc=%p <%d>\n", hdbc, cbErrorMsgMax);
if (RecNumber != 1 && RecNumber != -1)
return SQL_NO_DATA_FOUND;
if (cbErrorMsgMax < 0)
char *msg;
int status;
- mylog("**** PGAPI_EnvError: henv=%x <%d>\n", henv, cbErrorMsgMax);
+ mylog("**** PGAPI_EnvError: henv=%p <%d>\n", henv, cbErrorMsgMax);
if (RecNumber != 1 && RecNumber != -1)
return SQL_NO_DATA_FOUND;
if (cbErrorMsgMax < 0)
RETCODE ret;
UWORD flag = PODBC_ALLOW_PARTIAL_EXTRACT | PODBC_ERROR_CLEAR;
- mylog("**** PGAPI_Error: henv=%x, hdbc=%x hstmt=%d\n", henv, hdbc, hstmt);
+ mylog("**** PGAPI_Error: henv=%p, hdbc=%p hstmt=%d\n", henv, hdbc, hstmt);
if (cbErrorMsgMax < 0)
return SQL_ERROR;
int lf;
char rv = 1;
- mylog("in EN_Destructor, self=%x\n", self);
+ mylog("in EN_Destructor, self=%p\n", self);
/*
* the error messages are static strings distributed throughout the
{
int i;
- mylog("EN_add_connection: self = %x, conn = %x\n", self, conn);
+ mylog("EN_add_connection: self = %p, conn = %p\n", self, conn);
ENTER_CONNS_CS;
for (i = 0; i < MAX_CONNECTIONS; i++)
conns[i] = conn;
LEAVE_CONNS_CS;
- mylog(" added at i =%d, conn->henv = %x, conns[i]->henv = %x\n", i, conn->henv, conns[i]->henv);
+ mylog(" added at i =%d, conn->henv = %p, conns[i]->henv = %p\n", i, conn->henv, conns[i]->henv);
return TRUE;
}
#include <stdio.h>
#include <string.h>
+#ifndef WIN32
+#include <ctype.h>
+#endif /* WIN32 */
+
#include "environ.h"
#include "connection.h"
#include "statement.h"
return SQL_ERROR;
}
- mylog("**** %s: hstmt=%x, statement='%s'\n", func, hstmt, stmt->statement);
+ mylog("**** %s: hstmt=%p, statement='%s'\n", func, hstmt, stmt->statement);
if (0 != (flag & PODBC_WITH_HOLD))
SC_set_with_hold(stmt);
QResultClass *kres;
kres = res->next;
-inolog("res->next=%x\n", kres);
+inolog("res->next=%p\n", kres);
res->next = NULL;
SC_set_Result(stmt, kres);
res = kres;
ConnectionClass *conn;
ConnInfo *ci = NULL;
-inolog("%s:%x->internal=%d\n", func, stmt, stmt->internal);
+inolog("%s:%p->internal=%d\n", func, stmt, stmt->internal);
conn = SC_get_conn(stmt);
if (conn)
ci = &conn->connInfo;
else
SC_set_accessed_db(stmt);
}
-inolog("%s:%x->accessed=%d\n", func, stmt, SC_accessed_db(stmt));
+inolog("%s:%p->accessed=%d\n", func, stmt, SC_accessed_db(stmt));
return ret;
}
QResultClass *res;
BOOL cmd_success, start_stmt = FALSE;
-inolog("%s:%x->accessed=%d is_in=%d is_rb=%d is_tc=%d\n", func, stmt, SC_accessed_db(stmt),
+inolog("%s:%p->accessed=%d is_in=%d is_rb=%d is_tc=%d\n", func, stmt, SC_accessed_db(stmt),
CC_is_in_trans(conn), SC_is_rb_stmt(stmt), SC_is_tc_stmt(stmt));
switch (ret)
{
*stmt_string;
int lf;
- mylog("entering %s: hdbc=%x, henv=%x\n", func, hdbc, henv);
+ mylog("entering %s: hdbc=%p, henv=%p\n", func, hdbc, henv);
if (hdbc == SQL_NULL_HDBC && henv == SQL_NULL_HENV)
{
/* Done, now copy the params and then execute the statement */
ipdopts = SC_get_IPDF(estmt);
-inolog("ipdopts=%x\n", ipdopts);
+inolog("ipdopts=%p\n", ipdopts);
if (estmt->data_at_exec == 0)
{
BOOL exec_end;
inolog("i=%d", i);
if (apdopts->parameters[i].data_at_exec)
{
-inolog(" at exec buffer=%x", apdopts->parameters[i].buffer);
+inolog(" at exec buffer=%p", apdopts->parameters[i].buffer);
estmt->data_at_exec--;
estmt->current_exec_param = i;
estmt->put_data = FALSE;
case SQL_CONVERT_VARCHAR: /* ODBC 1.0 */
len = sizeof(SQLUINTEGER);
value = SQL_CVT_BIT | SQL_CVT_INTEGER;
-mylog("SQL_CONVERT_ mask=%x\n", value);
+mylog("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=%x\n", value);
+mylog("CONVERT_FUNCTIONS=" FORMAT_ULEN "\n", value);
break;
case SQL_CORRELATION_NAME: /* ODBC 1.0 */
BOOL search_pattern, list_schemas = FALSE;
SQLLEN cbRelname, cbRelkind;
- mylog("%s: entering...stmt=%x scnm=%x len=%d\n", func, stmt, NULL_IF_NULL(szTableOwner), cbTableOwner);
+ mylog("%s: entering...stmt=%p scnm=%p len=%d\n", func, stmt, NULL_IF_NULL(szTableOwner), cbTableOwner);
if (result = SC_initialize_and_recycle(stmt), SQL_SUCCESS != result)
return result;
if (stmt->internal)
ret = DiscardStatementSvp(stmt, ret, FALSE);
- mylog("%s: EXIT, stmt=%x, ret=%d\n", func, stmt, ret);
+ mylog("%s: EXIT, stmt=%p, ret=%d\n", func, stmt, ret);
return ret;
}
const char *like_or_eq = likeop;
const char *szSchemaName;
- mylog("%s: entering...stmt=%x scnm=%x len=%d\n", func, stmt, NULL_IF_NULL(szTableOwner), cbTableOwner);
+ mylog("%s: entering...stmt=%p scnm=%p len=%d\n", func, stmt, NULL_IF_NULL(szTableOwner), cbTableOwner);
if (result = SC_initialize_and_recycle(stmt), SQL_SUCCESS != result)
return result;
}
col_stmt = (StatementClass *) hcol_stmt;
- mylog("%s: hcol_stmt = %x, col_stmt = %x\n", func, hcol_stmt, col_stmt);
+ mylog("%s: hcol_stmt = %p, col_stmt = %p\n", func, hcol_stmt, col_stmt);
result = PGAPI_ExecDirect(hcol_stmt, columns_query, SQL_NTS, 0);
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
PGAPI_FreeStmt(hcol_stmt, SQL_DROP);
if (stmt->internal)
result = DiscardStatementSvp(stmt, result, FALSE);
- mylog("%s: EXIT, stmt=%x\n", func, stmt);
+ mylog("%s: EXIT, stmt=%p\n", func, stmt);
return result;
}
SQLSMALLINT internal_asis_type = SQL_C_CHAR, cbSchemaName;
const char *szSchemaName;
- mylog("%s: entering...stmt=%x scnm=%x len=%d colType=%d\n", func, stmt, NULL_IF_NULL(szTableOwner), cbTableOwner, fColType);
+ mylog("%s: entering...stmt=%p scnm=%p len=%d colType=%d\n", func, stmt, NULL_IF_NULL(szTableOwner), cbTableOwner, fColType);
if (result = SC_initialize_and_recycle(stmt), SQL_SUCCESS != result)
return result;
}
col_stmt = (StatementClass *) hcol_stmt;
- mylog("%s: hcol_stmt = %x, col_stmt = %x\n", func, hcol_stmt, col_stmt);
+ mylog("%s: hcol_stmt = %p, col_stmt = %p\n", func, hcol_stmt, col_stmt);
result = PGAPI_ExecDirect(hcol_stmt, columns_query, SQL_NTS, 0);
if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO))
PGAPI_FreeStmt(hcol_stmt, SQL_DROP);
if (stmt->internal)
result = DiscardStatementSvp(stmt, result, FALSE);
- mylog("%s: EXIT, stmt=%x\n", func, stmt);
+ mylog("%s: EXIT, stmt=%p\n", func, stmt);
return result;
}
const char *szSchemaName;
BOOL unknownf;
- mylog("%s: entering...stmt=%x scnm=%x len=%d\n", func, stmt, NULL_IF_NULL(szTableOwner), cbTableOwner);
+ mylog("%s: entering...stmt=%p scnm=%p len=%d\n", func, stmt, NULL_IF_NULL(szTableOwner), cbTableOwner);
if (result = SC_initialize_and_recycle(stmt), SQL_SUCCESS != result)
return result;
if (stmt->internal)
ret = DiscardStatementSvp(stmt, ret, FALSE);
- mylog("%s: EXIT, stmt=%x, ret=%d\n", func, stmt, ret);
+ mylog("%s: EXIT, stmt=%p, ret=%d\n", func, stmt, ret);
return ret;
}
const char *szSchemaName;
char *escSchemaName = NULL, *escTableName = NULL;
- mylog("%s: entering...stmt=%x scnm=%x len=%d\n", func, stmt, NULL_IF_NULL(szTableOwner), cbTableOwner);
+ mylog("%s: entering...stmt=%p scnm=%p len=%d\n", func, stmt, NULL_IF_NULL(szTableOwner), cbTableOwner);
if (result = SC_initialize_and_recycle(stmt), SQL_SUCCESS != result)
return result;
if (stmt->internal)
ret = DiscardStatementSvp(stmt, ret, FALSE);
- mylog("%s: EXIT, stmt=%x, ret=%d\n", func, stmt, ret);
+ mylog("%s: EXIT, stmt=%p, ret=%d\n", func, stmt, ret);
return ret;
}
Int2 result_cols;
UInt4 relid1, relid2;
- mylog("%s: entering...stmt=%x\n", func, stmt);
+ mylog("%s: entering...stmt=%p\n", func, stmt);
if (result = SC_initialize_and_recycle(stmt), SQL_SUCCESS != result)
return result;
if (stmt->internal)
ret = DiscardStatementSvp(stmt, ret, FALSE);
- mylog("%s(): EXIT, stmt=%x, ret=%d\n", func, stmt, ret);
+ mylog("%s(): EXIT, stmt=%p, ret=%d\n", func, stmt, ret);
return ret;
}
params = NULL;
else
{
- sscanf(params, "%d", &pgtype);
+ sscanf(params, "%u", &pgtype);
while (isdigit(*params))
params++;
}
const char *like_or_eq;
BOOL search_pattern;
- mylog("%s: entering... scnm=%x len=%d\n", func, szProcOwner, cbProcOwner);
+ mylog("%s: entering... scnm=%p len=%d\n", func, szProcOwner, cbProcOwner);
if (PG_VERSION_LT(conn, 6.5))
{
char *escSchemaName = NULL, *escTableName = NULL;
BOOL search_pattern;
- mylog("%s: entering... scnm=%x len-%d\n", func, NULL_IF_NULL(szTableOwner), cbTableOwner);
+ mylog("%s: entering... scnm=%p len-%d\n", func, NULL_IF_NULL(szTableOwner), cbTableOwner);
if (result = SC_initialize_and_recycle(stmt), SQL_SUCCESS != result)
return result;
{
void * alloced;
alloced = malloc(size);
-inolog(" alloced=%x(%d)\n", alloced, size);
+inolog(" alloced=%p(%d)\n", alloced, size);
if (alloced)
{
if (!alsize)
}
else
mylog("%s:calloc %dbyte\n", ALCERR, size);
-inolog("calloced = %x\n", alloced);
+inolog("calloced = %p\n", alloced);
return alloced;
}
void * debug_realloc(void * ptr, size_t size)
void * alloced = realloc(ptr, size);
if (!alloced)
{
- mylog("%s:debug_realloc %x error\n", ALCERR, ptr);
+ mylog("%s:debug_realloc %p error\n", ALCERR, ptr);
}
else if (!ptr)
{
}
}
- inolog("debug_realloc %x->%x\n", ptr, alloced);
+ inolog("debug_realloc %p->%p\n", ptr, alloced);
return alloced;
}
char * debug_strdup(const char * ptr)
char * alloced = strdup(ptr);
if (!alloced)
{
- mylog("%s:debug_strdup %x error\n", ALCERR, ptr);
+ mylog("%s:debug_strdup %p error\n", ALCERR, ptr);
}
else
{
altbl[tbsize].len = strlen(ptr) + 1;
tbsize++;
}
- inolog("debug_strdup %x->%x(%s)\n", ptr, alloced, alloced);
+ inolog("debug_strdup %p->%p(%s)\n", ptr, alloced, alloced);
return alloced;
}
}
}
if (! freed)
- mylog("%s:debug_freeing not found ptr %x\n", ALCERR, ptr);
+ mylog("%s:debug_freeing not found ptr %p\n", ALCERR, ptr);
else
- inolog("debug_freeing ptr=%x\n", ptr);
+ inolog("debug_freeing ptr=%p\n", ptr);
free(ptr);
}
if ((UInt4)out + len > (UInt4)(altbl[i].aladr) + altbl[i].len)
{
ret = FALSE;
- mylog("%s:%s:out_check found memory buffer overrun %x(%d)>=%x(%d)\n", ALCERR, name, out, len, altbl[i].aladr, altbl[i].len);
+ mylog("%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:debug_strcpy null pointer out=%x,in=%x\n", ALCERR, out, in);
+ mylog("%s:debug_strcpy null pointer out=%p,in=%p\n", ALCERR, out, in);
return NULL;
}
out_check(out, strlen(in) + 1, "debug_strcpy");
if (!out || !in)
{
- mylog("%s:%s null pointer out=%x,in=%x\n", ALCERR, func, out, in);
+ mylog("%s:%s null pointer out=%p,in=%p\n", ALCERR, func, out, in);
return NULL;
}
out_check(out, len, func);
if (!out || !in)
{
- mylog("%s:%s null pointer out=%x,in=%x\n", ALCERR, func, out, in);
+ mylog("%s:%s null pointer out=%p,in=%p\n", ALCERR, func, out, in);
return NULL;
}
out_check(out, len, func);
{
if (!out || !in)
{
- mylog("%s:debug_memcpy null pointer out=%x,in=%x\n", ALCERR, out, in);
+ mylog("%s:debug_memcpy null pointer out=%p,in=%p\n", ALCERR, out, in);
return NULL;
}
out_check(out, len, "debug_memcpy");
{
if (!out)
{
- mylog("%s:debug_memcpy null pointer out=%xx\n", ALCERR, out);
+ mylog("%s:debug_memcpy null pointer out=%p\n", ALCERR, out);
return NULL;
}
out_check(out, len, "debug_memset");
mylog("%s:memory leak found check count=%d alloc=%d\n", ALCERR, tbsize, alsize);
for (i = 0; i < tbsize; i++)
{
- mylog("%s:leak = %x(%d)\n", ALCERR, altbl[i].aladr, altbl[i].len);
+ mylog("%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 libpq loaded module=%x\n", hmodule);
+ mylog("psqlodbc path based libpq loaded module=%p\n", hmodule);
}
}
return hmodule;
int i;
static const char * const libarray[] = {"libssl32", "ssleay32"};
- mylog("DliErrorHook Notify=%d %x\n", dliNotify, pdli);
+ mylog("DliErrorHook Notify=%d %p\n", dliNotify, pdli);
switch (dliNotify)
{
case dliFailLoadLib:
if (!(hmodule = LoadLibrary(libpq)))
/* Second try the driver's directory */
hmodule = LIBPQ_load_from_psqlodbc_path();
- mylog("hmodule=%x\n", hmodule);
+ mylog("hmodule=%p\n", hmodule);
if (hmodule)
FreeLibrary(hmodule);
return (NULL != hmodule);
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
+#include <ctype.h>
#include <time.h>
#ifndef WIN32
inolog("malloc size=%d\n", length);
str = malloc(length + 1);
-inolog("str=%x\n", str);
+inolog("str=%p\n", str);
if (!str)
return NULL;
RETCODE ret;
ConnectionClass *conn = (ConnectionClass *) ConnectionHandle;
- mylog("[%s for %x]", func, ConnectionHandle);
+ mylog("[%s for %p]", func, ConnectionHandle);
#ifdef _HANDLE_ENLIST_IN_DTC_
DtcOnDisconnect(conn); /* must be called without holding the connection lock */
#endif /* _HANDLE_ENLIST_IN_DTC_ */
ENTER_CONN_CS(conn);
ret = PGAPI_AllocDesc(InputHandle, OutputHandle);
LEAVE_CONN_CS(conn);
-inolog("OutputHandle=%x\n", *OutputHandle);
+inolog("OutputHandle=%p\n", *OutputHandle);
break;
default:
ret = SQL_ERROR;
CSTR func = "SQLGetDiagField";
RETCODE ret;
- mylog("[[%s]] Handle=(%u,%x) Rec=%d Id=%d info=(%x,%d)\n", func, HandleType, Handle, RecNumber, DiagIdentifier, DiagInfo, BufferLength);
+ mylog("[[%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("[[SQLSetDescField]] h=%x rec=%d field=%d val=%x\n", DescriptorHandle, RecNumber, FieldIdentifier, Value);
+ mylog("[[SQLSetDescField]] h=%p rec=%d field=%d val=%p\n", DescriptorHandle, RecNumber, FieldIdentifier, Value);
ret = PGAPI_SetDescField(DescriptorHandle, RecNumber, FieldIdentifier,
Value, BufferLength);
return ret;
StatementClass *stmt = (StatementClass *) StatementHandle;
RETCODE ret;
- mylog("[[%s]] Handle=%x %d,%u\n", func, StatementHandle, Attribute, Value);
+ mylog("[[%s]] Handle=%p %d,%u\n", func, StatementHandle, Attribute, Value);
ENTER_STMT_CS(stmt);
SC_clear_error(stmt);
StartRollbackState(stmt);
StatementClass *stmt = (StatementClass *) hstmt;
ENTER_STMT_CS(stmt);
- mylog("[[%s]] Handle=%x %d\n", func, hstmt, operation);
+ mylog("[[%s]] Handle=%p %d\n", func, hstmt, operation);
SC_clear_error(stmt);
StartRollbackState(stmt);
ret = PGAPI_BulkOperations(hstmt, operation);
SQLSMALLINT *rgbL, blen = 0, bMax;
char *rgbD = NULL;
- mylog("[[%s]] Handle=(%u,%x) Rec=%d Id=%d info=(%x,%d)\n", func, fHandleType,
+ mylog("[[%s]] Handle=(%u,%p) Rec=%d Id=%d info=(%p,%d)\n", func, fHandleType,
handle, iRecord, fDiagField, rgbDiagInfo, cbDiagInfoMax);
switch (fDiagField)
{
utf8_to_ucs2(szOut, maxlen, szConnStrOut, cbConnStrOutMax);
if (outlen >= cbConnStrOutMax)
{
-inolog("cbConnstrOutMax=%d pcb=%x\n", cbConnStrOutMax, pcbConnStrOut);
+inolog("cbConnstrOutMax=%d pcb=%p\n", cbConnStrOutMax, pcbConnStrOut);
if (SQL_SUCCESS == ret)
{
CC_set_error(conn, CONN_TRUNCATED, "the ConnStrOut is too small", func);
if (stmt)
{
SC_set_error(stmt, STMT_NOT_IMPLEMENTED_ERROR, "Unknown statement option (Set)", NULL);
- sprintf(option, "fOption=%d, vParam=%ld", fOption, vParam);
+ sprintf(option, "fOption=%d, vParam=" FORMAT_LEN, fOption, vParam);
SC_log_error(func, option, stmt);
}
if (conn)
{
CC_set_error(conn, CONN_NOT_IMPLEMENTED_ERROR, "Unknown statement option (Set)", func);
- sprintf(option, "fOption=%d, vParam=%ld", fOption, vParam);
+ sprintf(option, "fOption=%d, vParam=" FORMAT_LEN, fOption, vParam);
CC_log_error(func, option, conn);
}
char option[64];
CC_set_error(conn, CONN_UNSUPPORTED_OPTION, "Unknown connect option (Set)", func);
- sprintf(option, "fOption=%d, vParam=%ld", fOption, vParam);
+ sprintf(option, "fOption=%d, vParam=" FORMAT_LEN, fOption, vParam);
if (fOption == 30002 && vParam)
{
int cmp;
HSTMT hcol_stmt = NULL;
QResultClass *res;
-inolog("getCOLIfromTI reloid=%u ti=%x\n", reloid, wti);
+inolog("getCOLIfromTI reloid=%u ti=%p\n", reloid, wti);
if (!conn)
conn = SC_get_conn(stmt);
if (!wti) /* SQLColAttribute case */
}
*pti = wti;
}
-inolog("fi=%x greloid=%d col_info=%x\n", wti, greloid, wti->col_info);
+inolog("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)
STR_TO_NAME(wti->table_name,
QR_get_value_backend_row(res, 0, COLUMNS_TABLE_NAME));
}
-inolog("#2 %x->table_name=%s(%u)\n", wti, PRINT_NAME(wti->table_name), wti->table_oid);
+inolog("#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
STR_TO_NAME(wti->table_name,
QR_get_value_backend_row(res, 0, COLUMNS_TABLE_NAME));
}
-inolog("#1 %x->table_name=%s(%u)\n", wti, PRINT_NAME(wti->table_name), wti->table_oid);
+inolog("#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))
{
RETCODE ret = SQL_SUCCESS;
SQLINTEGER len = 0;
- mylog("%s Handle=%x %d\n", func, StatementHandle, Attribute);
+ mylog("%s Handle=%p %d\n", func, StatementHandle, Attribute);
switch (Attribute)
{
case SQL_ATTR_FETCH_BOOKMARK_PTR: /* 16 */
RETCODE ret = SQL_SUCCESS;
BOOL unsupported = FALSE;
- mylog("%s for %x: %d %x\n", func, ConnectionHandle, Attribute, Value);
+ mylog("%s for %p: %d %p\n", func, ConnectionHandle, Attribute, Value);
switch (Attribute)
{
case SQL_ATTR_METADATA_ID:
case SQL_ATTR_ENLIST_IN_DTC:
#ifdef WIN32
#ifdef _HANDLE_ENLIST_IN_DTC_
- mylog("SQL_ATTR_ENLIST_IN_DTC %x request received\n", Value);
+ mylog("SQL_ATTR_ENLIST_IN_DTC %p request received\n", Value);
if (conn->connInfo.xa_opt != 0)
return EnlistInDtc(conn, Value, conn->connInfo.xa_opt);
#endif /* _HANDLE_ENLIST_IN_DTC_ */
if (unsupported)
{
char msg[64];
- snprintf(msg, sizeof(msg), "Couldn't set unsupported connect attribute %ld", (LONG_PTR) Value);
+ snprintf(msg, sizeof(msg), "Couldn't set unsupported connect attribute " FORMAT_LPTR, (LONG_PTR) Value);
CC_set_error(conn, CONN_OPTION_NOT_FOR_THE_DRIVER, msg, func);
return SQL_ERROR;
}
RETCODE ret = SQL_SUCCESS;
DescriptorClass *desc = (DescriptorClass *) DescriptorHandle;
- mylog("%s h=%x rec=%d field=%d blen=%d\n", func, DescriptorHandle, RecNumber, FieldIdentifier, BufferLength);
+ mylog("%s h=%p rec=%d field=%d blen=%d\n", func, DescriptorHandle, RecNumber, FieldIdentifier, BufferLength);
switch (desc->desc_type)
{
case SQL_ATTR_APP_ROW_DESC:
RETCODE ret = SQL_SUCCESS;
DescriptorClass *desc = (DescriptorClass *) DescriptorHandle;
- mylog("%s h=%x rec=%d field=%d val=%x,%d\n", func, DescriptorHandle, RecNumber, FieldIdentifier, Value, BufferLength);
+ mylog("%s h=%p rec=%d field=%d val=%p,%d\n", func, DescriptorHandle, RecNumber, FieldIdentifier, Value, BufferLength);
switch (desc->desc_type)
{
case SQL_ATTR_APP_ROW_DESC:
CSTR func = "PGAPI_SetStmtAttr";
StatementClass *stmt = (StatementClass *) StatementHandle;
- mylog("%s Handle=%x %d,%u\n", func, StatementHandle, Attribute, Value);
+ mylog("%s Handle=%p %d,%u\n", func, StatementHandle, Attribute, Value);
switch (Attribute)
{
case SQL_ATTR_ENABLE_AUTO_IPD: /* 15 */
else
{
stmt->ard = (ARDClass *) Value;
-inolog("set ard=%x\n", stmt->ard);
+inolog("set ard=%p\n", stmt->ard);
}
break;
case SQL_ATTR_APP_PARAM_DESC: /* 10011 */
*
* Comments: See "notice.txt" for copyright and license information.
*
- * $Id: psqlodbc.h,v 1.111 2006/10/12 01:55:33 h-saito Exp $
+ * $Id: psqlodbc.h,v 1.112 2006/10/17 16:18:56 hinoue Exp $
*
*/
#ifdef WIN32
#define ssize_t SSIZE_T
+#define FORMAT_SIZE_T "%Iu" /* size_t */
+#define FORMAT_SSIZE_T "%Id" /* ssize_t */
+#define FORMAT_INTEGER "%ld" /* SQLINTEGER */
+#define FORMAT_UINTEGER "%lu" /* SQLUINTEGER */
+#ifdef _WIN64
+#define FORMAT_LEN "%I64d" /* SQLLEN */
+#define FORMAT_ULEN "%I64u" /* SQLULEN */
+#define FORMAT_LPTR "%I64d" /* LONG_PTR */
+#define FORMAT_ULPTR "%I64u" /* ULONG_PTR */
#else
+#define FORMAT_LEN "%ld" /* SQLLEN */
+#define FORMAT_ULEN "%lu" /* SQLULEN */
+#define FORMAT_LPTR "%ld" /* LONG_PTR */
+#define FORMAT_ULPTR "%lu" /* ULONG_PTR */
+#endif /* _WIN64 */
+#else
+#define FORMAT_SIZE_T "%xu" /* size_t */
+#define FORMAT_SSIZE_T "%xd" /* ssize_t */
+#ifndef HAVE_SSIZE_T
+typedef long ssize_t
+#endif /* HAVE_SSIZE_T */
#if (SIZE_OF_VOID_P == SIZE_OF_LONG)
typedef long LONG_PTR;
typedef unsigned long ULONG_PTR;
+#define FORMAT_LPTR "%ld" /* LONG_PTR */
+#define FORMAT_ULPTR "%lu" /* ULONG_PTR */
+#elif defined (HAVE_LONG_LONG)
+typedef long long LONG_PTR;
+typedef unsigned long long ULONG_PTR;
+#define FORMAT_LPTR "%lld" /* LONG_PTR */
+#define FORMAT_ULPTR "%llu" /* ULONG_PTR */
#else
-typedef SQLLEN LONG_PTR;
-typedef unsigned SQLLEN ULONG_PTR;
+#error neither long nor long long is defined
+#endif /* SIZE_OF_VOID_P */
+#if (SIZE_OF_VOID_P == 8)
+#define FORMAT_INTEGER "%d" /* SQLINTEGER */
+#define FORMAT_UINTEGER "%u" /* SQLUINTEGER */
+#if defined(WITH_UNIXODBC) && !defined(BUILD_REAL_64_BIT_MODE)
+#define FORMAT_LEN "%d" /* SQLLEN */
+#define FORMAT_ULEN "%u" /* SQLULEN */
+#else
+#define FORMAT_LEN "%ld" /* SQLLEN */
+#define FORMAT_ULEN "%lu" /* SQLULEN */
+#endif /* WITH_UNIXODBC */
+#else
+#define FORMAT_LEN "%ld" /* SQLLEN */
+#define FORMAT_ULEN "%lu" /* SQLULEN */
+#define FORMAT_INTEGER "%ld" /* SQLINTEGER */
+#define FORMAT_UINTEGER "%lu" /* SQLUINTEGER */
#endif /* SIZE_OF_VOID_P */
-#ifndef HAVE_SSIZE_T
-typedef long ssize_t
-#endif /* HAVE_SSIZE_T */
#endif /* WIN32 */
#define CAST_PTR(type, ptr) (type)((LONG_PTR)(ptr))
#define CAST_UPTR(type, ptr) (type)((ULONG_PTR)(ptr))
QR_set_conn(self, conn);
- mylog("%s: cursor = '%s', self->cursor=%x\n", func, (cursor == NULL) ? "" : cursor, QR_get_cursor(self));
+ mylog("%s: cursor = '%s', self->cursor=%p\n", func, (cursor == NULL) ? "" : cursor, QR_get_cursor(self));
if (cursor && !cursor[0])
cursor = NULL;
/* End the transaction if there are no cursors left on this conn */
if (CC_is_in_autocommit(conn) && CC_cursor_count(conn) == 0)
{
- mylog("QResult: END transaction on conn=%x\n", conn);
+ mylog("QResult: END transaction on conn=%p\n", conn);
if (!CC_commit(conn))
{
QR_set_message(self, "Error reading the tuple");
return FALSE;
}
-inolog("!!%x->cursTup=%d total_read=%d\n", self, self->cursTuple, self->num_total_read);
+inolog("!!%p->cursTup=%d total_read=%d\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;
inolog("!!cursTup=%d total_read=%d\n", self->cursTuple, self->num_total_read);
BOOL reached_eof_now = FALSE, curr_eof; /* detecting EOF is pretty important */
Int4 response_length;
-inolog("Oh %x->fetch_number=%d\n", self, self->fetch_number);
+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 ? stmt->currTuple : -1, self->ad_count, QR_get_num_total_tuples(self), self->rowset_size_include_ommitted);
num_total_rows = QR_get_num_total_tuples(self);
}
else
self->cache_size = req_size;
-inolog("cache=%d rowset=%d movement=%d\n", self->cache_size, req_size, movement);
- sprintf(movecmd, "move backward %lu in \"%s\"", movement, QR_get_cursor(self));
+inolog("cache=%d rowset=%d movement=" FORMAT_ULEN "\n", self->cache_size, req_size, movement);
+ sprintf(movecmd, "move backward " FORMAT_ULEN " in \"%s\"", movement, QR_get_cursor(self));
}
else if (QR_is_moving_forward(self))
- sprintf(movecmd, "move %lu in \"%s\"", movement, QR_get_cursor(self));
+ sprintf(movecmd, "move " FORMAT_ULEN " in \"%s\"", movement, QR_get_cursor(self));
else
{
sprintf(movecmd, "move all in \"%s\"", QR_get_cursor(self));
moved = movement;
if (sscanf(mres->command, "MOVE %lu", &moved) > 0)
{
-inolog("moved=%d ? %d\n", moved, movement);
+inolog("moved=%d ? " FORMAT_ULEN "\n", moved, movement);
if (moved < movement)
{
if (0 < moved)
if (back_offset + 1 > (Int4) self->ad_count)
{
bmovement = back_offset + 1 - self->ad_count;
- sprintf(movecmd, "move backward %lu in \"%s\"", bmovement, QR_get_cursor(self));
+ sprintf(movecmd, "move backward " FORMAT_ULEN " in \"%s\"", bmovement, QR_get_cursor(self));
QR_Destructor(mres);
mres = CC_send_query(conn, movecmd, NULL, 0, stmt);
if (!QR_command_maybe_successful(mres))
/* return a row from cache */
mylog("%s: fetch_number < fcount: returning tuple %d, fcount = %d\n", func, fetch_number, num_backend_rows);
self->tupleField = the_tuples + (fetch_number * num_fields);
-inolog("tupleField=%x\n", self->tupleField);
+inolog("tupleField=%p\n", self->tupleField);
/* move to next row */
QR_inc_next_in_cache(self);
return TRUE;
SOCK_get_string(sock, cmdbuffer, ERROR_MSG_LENGTH);
QR_set_command(self, cmdbuffer);
- mylog("end of tuple list -- setting inUse to false: this = %x %s\n", self, cmdbuffer);
+ mylog("end of tuple list -- setting inUse to false: this = %p %s\n", self, cmdbuffer);
qlog(" [ fetched %d rows ]\n", self->num_total_read);
mylog("_%s: 'C' fetch_total = %d & this_fetch = %d\n", func, self->num_total_read, self->num_cached_rows);
QResultClass *result = SC_get_Curres(stmt);
BOOL exec_ok = TRUE;
- mylog("%s: result = %x, status = %d, numcols = %d\n", func, result, stmt->status, result != NULL ? QR_NumResultCols(result) : -1);
+ mylog("%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)
{
{
if (SC_parsed_status(stmt) == STMT_PARSE_NONE)
{
- mylog("PGAPI_NumResultCols: calling parse_statement on stmt=%x\n", stmt);
+ mylog("PGAPI_NumResultCols: calling parse_statement on stmt=%p\n", stmt);
parse_statement(stmt, FALSE);
}
{
if (SC_parsed_status(stmt) == STMT_PARSE_NONE)
{
- mylog("%s: calling parse_statement on stmt=%x\n", func, stmt);
+ mylog("%s: calling parse_statement on stmt=%p\n", func, stmt);
parse_statement(stmt, FALSE);
}
- mylog("PARSE: DescribeCol: icol=%d, stmt=%x, stmt->nfld=%d, stmt->fi=%x\n", icol, stmt, irdflds->nfields, irdflds->fi);
+ mylog("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)
{
field_type = (conn->lobj_type == fi->columntype) ? fi->columntype : FI_type(fi);
}
- mylog("colAttr: col %d field_type=%d fi,ti=%x,%x\n", col_idx, field_type, fi, ti);
+ mylog("colAttr: col %d field_type=%d fi,ti=%p,%p\n", col_idx, field_type, fi, ti);
switch (fDescType)
{
#else
case SQL_COLUMN_NAME:
#endif /* ODBCVER */
-inolog("fi=%x", fi);
+inolog("fi=%p", fi);
if (fi)
inolog(" (%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);
ConnInfo *ci;
SQLSMALLINT target_type;
- mylog("%s: enter, stmt=%x\n", func, stmt);
+ mylog("%s: enter, stmt=%p\n", func, stmt);
if (!stmt)
{
BindInfoClass *bookmark;
RETCODE retval = SQL_SUCCESS;
- mylog("%s: stmt = %x, stmt->result= %x\n", func, stmt, stmt ? SC_get_Curres(stmt) : NULL);
+ mylog("%s: stmt = %p, stmt->result= %p\n", func, stmt, stmt ? SC_get_Curres(stmt) : NULL);
if (!stmt)
{
UWORD pstatus;
BOOL currp_is_valid, reached_eof;
- mylog("%s: stmt=%x rowsetSize=%d\n", func, stmt, rowsetSize);
+ mylog("%s: stmt=%p rowsetSize=%d\n", func, stmt, rowsetSize);
if (!stmt)
{
{
if (tuple->value)
{
-inolog("freeing tuple[%d][%d].value=%x\n", i / num_fields, i % num_fields, tuple->value);
+inolog("freeing tuple[%d][%d].value=%p\n", i / num_fields, i % num_fields, tuple->value);
free(tuple->value);
tuple->value = NULL;
}
{
SQLLEN i;
-inolog("ReplaceCachedRows %x num_fields=%d num_rows=%d\n", otuple, num_fields, num_rows);
+inolog("ReplaceCachedRows %p num_fields=%d num_rows=%d\n", otuple, num_fields, num_rows);
for (i = 0; i < num_fields * num_rows; i++, ituple++, otuple++)
{
if (otuple->value)
{
int i;
-inolog("MoveCachedRows %x num_fields=%d num_rows=%d\n", otuple, num_fields, num_rows);
+inolog("MoveCachedRows %p num_fields=%d num_rows=%d\n", otuple, num_fields, num_rows);
for (i = 0; i < num_fields * num_rows; i++, ituple++, otuple++)
{
if (otuple->value)
if (!res) return;
num_fields = res->num_fields;
-inolog("AddAdded index=%d, tuple=%x, num_fields=%d\n", index, tuple_added, num_fields);
+inolog("AddAdded index=%d, tuple=%p, num_fields=%d\n", index, tuple_added, num_fields);
ad_count = res->ad_count;
res->ad_count++;
if (QR_get_cursor(res))
int i;
UWORD status;
- mylog("CommitAdded res=%x\n", res);
+ mylog("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--)
int i;
UWORD status;
- mylog("CommitUpdated res=%x\n", res);
+ mylog("CommitUpdated res=%p\n", res);
if (!res) return;
if (!QR_get_cursor(res))
return;
status = wkey->status;
}
}
-inolog(" index=%d status=%x", index, status);
+inolog(" index=%d status=%hx", index, status);
if (kres_is_valid)
{
QResultClass *qres;
char tidval[32];
BOOL use_ctid = TRUE, data_in_cache = TRUE, key_in_cache = TRUE;
- mylog("positioned load fi=%x ti=%x\n", irdflds->fi, stmt->ti);
+ mylog("positioned load fi=%p ti=%p\n", irdflds->fi, stmt->ti);
rcnt = 0;
if (count)
*count = 0;
QResultClass *res, *qres;
RETCODE ret = SQL_ERROR;
- mylog("positioned new ti=%x\n", stmt->ti);
+ mylog("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);
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=%x ti=%x\n", s.irow, QR_get_rowstart_in_cache(s.res), fi, s.stmt->ti);
+ mylog("POS UPDATE %d+%d 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 (!s.stmt->updatable)
used = LENADDR_SHIFT(used, bind_size * s.irow);
else
used = LENADDR_SHIFT(used, s.irow * sizeof(SQLLEN));
- mylog("%d used=%d,%x\n", i, *used, used);
+ mylog("%d used=%d,%p\n", i, *used, used);
if (*used != SQL_IGNORE && fi[i]->updatable)
{
if (upd_cols)
const char *bestitem;
const char *bestqual;
- mylog("POS DELETE ti=%x\n", stmt->ti);
+ mylog("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);
char buf[32];
SQLULEN offset = opts->row_offset_ptr ? *opts->row_offset_ptr : 0;
- snprintf(buf, sizeof(buf), "%ld", SC_make_bookmark(addpos));
+ snprintf(buf, sizeof(buf), FORMAT_LEN, SC_make_bookmark(addpos));
SC_set_current_col(stmt, -1);
copy_and_convert_field(stmt,
PG_TYPE_INT4,
OID fieldtype;
int func_cs_count = 0;
- mylog("POS ADD fi=%x ti=%x\n", fi, stmt->ti);
+ mylog("POS ADD fi=%p ti=%p\n", fi, stmt->ti);
s.stmt = stmt;
s.irow = irow;
if (!(s.res = SC_get_Curres(s.stmt)))
CSTR func = "PGAPI_SetCursorName";
StatementClass *stmt = (StatementClass *) hstmt;
- mylog("PGAPI_SetCursorName: hstmt=%x, szCursor=%x, cbCursorMax=%d\n", hstmt, szCursor, cbCursor);
+ mylog("PGAPI_SetCursorName: hstmt=%p, szCursor=%p, cbCursorMax=%d\n", hstmt, szCursor, cbCursor);
if (!stmt)
{
size_t len = 0;
RETCODE result;
- mylog("PGAPI_GetCursorName: hstmt=%x, szCursor=%x, cbCursorMax=%d, pcbCursor=%x\n", hstmt, szCursor, cbCursorMax, pcbCursor);
+ mylog("PGAPI_GetCursorName: hstmt=%p, szCursor=%p, cbCursorMax=%d, pcbCursor=%p\n", hstmt, szCursor, cbCursorMax, pcbCursor);
if (!stmt)
{
stmt = SC_Constructor(conn);
- mylog("**** PGAPI_AllocStmt: hdbc = %x, stmt = %x\n", hdbc, stmt);
+ mylog("**** PGAPI_AllocStmt: hdbc = %p, stmt = %p\n", hdbc, stmt);
if (!stmt)
{
CSTR func = "PGAPI_FreeStmt";
StatementClass *stmt = (StatementClass *) hstmt;
- mylog("%s: entering...hstmt=%x, fOption=%d\n", func, hstmt, fOption);
+ mylog("%s: entering...hstmt=%p, fOption=%hi\n", func, hstmt, fOption);
if (!stmt)
{
QResultClass *res = SC_get_Result(self);
if (!self) return FALSE;
- mylog("SC_Destructor: self=%x, self->result=%x, self->hdbc=%x\n", self, res, self->hdbc);
+ mylog("SC_Destructor: self=%p, self->result=%p, self->hdbc=%p\n", self, res, self->hdbc);
SC_clear_error(self);
if (STMT_EXECUTING == self->status)
{
QResultClass *res = SC_get_Curres(stmt);
SQLLEN incr = start - stmt->rowset_start;
-inolog("%x->SC_set_rowstart %d->%d(%s) ", stmt, stmt->rowset_start, start, valid_base ? "valid" : "unknown");
+inolog("%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);
}
if (!QR_get_cursor(res))
res->key_base = start;
-inolog(":QR result=%d(%s)", QR_get_rowstart_in_cache(res), QR_has_valid_base(res) ? "valid" : "unknown");
+inolog(":QR result=" FORMAT_LEN "(%s)", QR_get_rowstart_in_cache(res), QR_has_valid_base(res) ? "valid" : "unknown");
}
stmt->rowset_start = start;
-inolog(":stmt result=%d\n", stmt->rowset_start);
+inolog(":stmt result=" FORMAT_LEN "\n", stmt->rowset_start);
}
void
SC_inc_rowset_start(StatementClass *stmt, SQLLEN inc)
ConnectionClass *conn;
QResultClass *res;
- mylog("%s: self= %x\n", func, self);
+ mylog("%s: self= %p\n", func, self);
SC_clear_error(self);
/* This would not happen */
SC_set_rowset_start(self, -1, FALSE);
SC_set_current_col(self, -1);
self->bind_row = 0;
-inolog("%s statement=%x ommitted=0\n", func, self);
+inolog("%s statement=%p ommitted=0\n", func, self);
self->last_fetch_count = self->last_fetch_count_include_ommitted = 0;
self->__error_message = NULL;
{
StatementClass *child = stmt, *parent;
-inolog("SC_get_ancestor in stmt=%x\n", stmt);
+inolog("SC_get_ancestor in stmt=%p\n", stmt);
for (child = stmt, parent = child->execute_parent; parent; child = parent, parent = child->execute_parent)
{
- inolog("parent=%x\n", parent);
+ inolog("parent=%p\n", parent);
}
return child;
}
QResultClass *self_res;
BOOL repstate;
-inolog("SC_set_error_from_res %x->%x check=%d\n", from_res ,self, check);
+inolog("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 %x->%x check=%d\n", from ,self, check);
+inolog("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 %x->%x\n", from ,self);
+inolog("SC_full_error_copy %p->%p\n", from ,self);
if (self->__error_message)
{
free(self->__error_message);
/* TupleField *tupleField; */
-inolog("%s statement=%x ommitted=0\n", func, self);
+inolog("%s statement=%p ommitted=0\n", func, self);
self->last_fetch_count = self->last_fetch_count_include_ommitted = 0;
coli = QR_get_fields(res); /* the column info */
- mylog("fetch_cursor=%d, %x->total_read=%d\n", SC_is_fetchcursor(self), res, res->num_total_read);
+ mylog("fetch_cursor=%d, %p->total_read=%d\n", SC_is_fetchcursor(self), res, res->num_total_read);
if (!SC_is_fetchcursor(self))
{
if (kres_ridx >= 0 && kres_ridx < res->num_cached_keys)
{
UWORD pstatus = res->keyset[kres_ridx].status;
-inolog("SC_ pstatus[%d]=%x fetch_count=%d\n", kres_ridx, pstatus, self->last_fetch_count);
+inolog("SC_ pstatus[%d]=%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=%x ommitted++\n", func, self);
+inolog("%s: stmt=%p ommitted++\n", func, self);
self->last_fetch_count_include_ommitted++;
opts = SC_get_ARDF(self);
char buf[32];
SQLLEN offset = opts->row_offset_ptr ? *opts->row_offset_ptr : 0;
- sprintf(buf, "%ld", SC_get_bookmark(self));
+ sprintf(buf, FORMAT_ULEN, SC_get_bookmark(self));
SC_set_current_col(self, -1);
result = copy_and_convert_field(self, 0, buf,
SQL_C_ULONG, bookmark->buffer + offset, 0,
extend_getdata_info(gdata, opts->allocated, TRUE);
for (lf = 0; lf < num_cols; lf++)
{
- mylog("fetch: cols=%d, lf=%d, opts = %x, opts->bindings = %x, buffer[] = %x\n", num_cols, lf, opts, opts->bindings, opts->bindings[lf].buffer);
+ mylog("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 */
gdata->gdata[lf].data_left = -1;
}
if (issue_begin)
{
- mylog(" about to begin a transaction on statement = %x\n", self);
+ mylog(" about to begin a transaction on statement = %p\n", self);
if (PG_VERSION_GE(conn, 7.1))
qflag |= GO_INTO_TRANSACTION;
else if (!CC_begin(conn))
if (issue_begin)
CC_begin(conn);
res = SC_get_Result(self);
-inolog("get_Result=%x\n", res);
+inolog("get_Result=%p\n", res);
if (!plan_name)
plan_name = "";
if (!SendBindRequest(self, plan_name))
char fetch[128];
qflag |= (SQL_CONCUR_READ_ONLY != self->options.scroll_concurrency ? CREATE_KEYSET : 0);
- mylog(" Sending SELECT statement on stmt=%x, cursor_name='%s' qflag=%d,%d\n", self, SC_cursor_name(self), qflag, self->options.scroll_concurrency);
+ mylog(" 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 */
res = CC_send_query(conn, self->stmt_with_params, NULL, qflag, SC_get_ancestor(self));
* will correct for any discrepancies in sizes and adjust the
* cache accordingly.
*/
- sprintf(fetch, "fetch %ld in \"%s\"", qi.row_size, SC_cursor_name(self));
+ sprintf(fetch, "fetch " FORMAT_LEN " in \"%s\"", qi.row_size, SC_cursor_name(self));
res = CC_send_query(conn, fetch, &qi, qflag, SC_get_ancestor(self));
if (SC_is_with_hold(self))
else
{
/* not a SELECT statement so don't use a cursor */
- mylog(" it's NOT a select statement: stmt=%x\n", self);
+ mylog(" 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("!!%x->SC_is_concat_pre=%x res=%x\n", self, self->miscinfo, res);
+inolog("!!%p->SC_is_concat_pre=%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
* user the keyset info of the 2nd query.
else if (SC_is_concat_prepare_exec(self))
{
tres = res->next;
-inolog("res->next=%x\n", tres);
+inolog("res->next=%p\n", tres);
res->next = NULL;
if (res != SC_get_Result(self))
QR_Destructor(res);
stmt->callbacks[stmt->num_callbacks].data = data;
stmt->num_callbacks++;
-inolog("enqueueNeedDataCallack stmt=%x, func=%x, count=%d\n", stmt, func, stmt->num_callbacks);
+inolog("enqueueNeedDataCallack stmt=%p, func=%p, count=%d\n", stmt, func, stmt->num_callbacks);
return stmt->num_callbacks;
}
if (SC_get_errornumber(self) > 0)
{
qlog(" ------------------------------------------------------------\n");
- qlog(" hdbc=%x, stmt=%x, result=%x\n", self->hdbc, self, res);
+ qlog(" hdbc=%p, stmt=%p, result=%p\n", self->hdbc, self, res);
qlog(" prepare=%d, internal=%d\n", self->prepare, self->internal);
- qlog(" bindings=%x, bindings_allocated=%d\n", opts->bindings, opts->allocated);
- qlog(" parameters=%x, parameters_allocated=%d\n", apdopts->parameters, apdopts->allocated);
+ qlog(" bindings=%p, bindings_allocated=%d\n", opts->bindings, opts->allocated);
+ qlog(" parameters=%p, parameters_allocated=%d\n", apdopts->parameters, apdopts->allocated);
qlog(" statement_type=%d, statement='%s'\n", self->statement_type, nullcheck(self->statement));
qlog(" stmt_with_params='%s'\n", nullcheck(self->stmt_with_params));
qlog(" data_at_exec=%d, current_exec_param=%d, put_data=%d\n", self->data_at_exec, self->current_exec_param, self->put_data);
if (res)
{
- qlog(" fields=%x, backend_tuples=%x, tupleField=%d, conn=%x\n", res->fields, res->backend_tuples, res->tupleField, res->conn);
+ qlog(" fields=%p, backend_tuples=%p, tupleField=%d, conn=%p\n", res->fields, res->backend_tuples, res->tupleField, res->conn);
qlog(" fetch_count=%d, num_total_rows=%d, num_fields=%d, cursor='%s'\n", res->fetch_number, QR_get_num_total_tuples(res), res->num_fields, nullcheck(QR_get_cursor(res)));
qlog(" message='%s', command='%s', notice='%s'\n", nullcheck(res->message), nullcheck(res->command), nullcheck(res->notice));
qlog(" status=%d, inTuples=%d\n", QR_get_rstatus(res), QR_is_fetching_tuples(res));
char pre_executing; /* This statement is prematurely executing */
char inaccurate_result; /* Current status is PREMATURE but
* result is inaccurate */
- char miscinfo;
+ unsigned char miscinfo;
char updatable;
SQLLEN diag_row_count;
char *load_statement; /* to (re)load updatable individual rows */
#ifndef __VERSION_H__
#define __VERSION_H__
-#define POSTGRESDRIVERVERSION "08.02.0103"
-#define POSTGRES_RESOURCE_VERSION "08.02.0103\0"
-#define PG_DRVFILE_VERSION 8,2,01,03
+#define POSTGRESDRIVERVERSION "08.02.0104"
+#define POSTGRES_RESOURCE_VERSION "08.02.0104\0"
+#define PG_DRVFILE_VERSION 8,2,01,04
#endif
*/
#include "psqlodbc.h"
+#include <malloc.h>
#ifdef WIN32
#ifdef _DEBUG
#ifndef _MEMORY_DEBUG_
#include <stdlib.h>
-#include <malloc.h>
#define _CRTDBG_MAP_ALLOC
#include <crtdbg.h>
#endif /* _MEMORY_DEBUG_ */
#define byte3_mask2 0x0fc0
#define byte3_mask3 0x003f
+#include <ctype.h>
#ifndef WIN32
#ifdef HAVE_ISWASCII
#include <wctype.h>
#else
#include <wchar.h>
-#include <ctype.h>
int iswascii(wchar_t c)
{
return isascii(wctob(c));
char *ucs2_to_utf8(const SQLWCHAR *ucs2str, SQLLEN ilen, SQLLEN *olen, BOOL lower_identifier)
{
char * utf8str;
-/*mylog("ucs2_to_utf8 %x ilen=%d ", ucs2str, ilen);*/
+/*mylog("ucs2_to_utf8 %p ilen=%d ", ucs2str, ilen);*/
if (!ucs2str)
{
projects / psqlodbc.git / commitdiff