static int
ngx_dbd_freetds_err_handler(DBPROCESS *db, int severity, int dberr, int oserr,
char *dberrstr, char *oserrstr)
{
ngx_log_t *log;
ngx_dbd_t *dbd;
dbd = dbgetuserdata(db);
if (dbd != NULL) {
log = dbd->log;
} else {
log = ngx_cycle->log;
}
if (dberrstr == NULL) {
dberrstr = "";
}
if (oserrstr == NULL) {
oserrstr = "";
}
/* TODO */
ngx_log_error(NGX_LOG_ERR, log, 0,
"severity: %d, dberr: %d, oserr: %d, "
"dberrstr: %s, oserrstr: %s",
severity, dberr, oserr, dberrstr, oserrstr);
return 0;
}
int msg_handler(DBPROCESS *dbproc, DBINT msgno, int msgstate,
int severity, char *msgtext, char *srvname, char *procname, DBUSMALLINT line)
{
pdo_dblib_err *einfo;
TSRMLS_FETCH();
if (severity) {
einfo = (pdo_dblib_err*)dbgetuserdata(dbproc);
if (!einfo) {
einfo = &DBLIB_G(err);
}
if (einfo->lastmsg) {
efree(einfo->lastmsg);
}
einfo->lastmsg = estrdup(msgtext);
}
#if 0
php_error_docref(NULL TSRMLS_CC, E_WARNING, "dblib message: %s (severity %d)", msgtext, severity);
#endif
return 0;
}
static VALUE rb_tinytds_result_cancel(VALUE self) {
tinytds_client_userdata *userdata;
GET_RESULT_WRAPPER(self);
userdata = (tinytds_client_userdata *)dbgetuserdata(rwrap->client);
if (rwrap->client && !userdata->dbcancel_sent) {
rb_tinytds_result_ok_helper(rwrap->client);
dbcancel(rwrap->client);
userdata->dbcancel_sent = 1;
userdata->dbsql_sent = 0;
}
return Qtrue;
}
int
syb_err_handler(DBPROCESS * dbproc, int severity, int dberr, int oserr, char *dberrstr, char *oserrstr)
{
int *pexpected_dberr;
/*
* For server messages, cancel the query and rely on the
* message handler to spew the appropriate error messages out.
*/
if (dberr == SYBESMSG)
return INT_CANCEL;
/*
* If the user data indicates this is an expected error message (because we're testing the
* error propogation, say) then indicate this message was anticipated.
*/
if (dbproc != NULL) {
pexpected_dberr = (int *) dbgetuserdata(dbproc);
if (pexpected_dberr && *pexpected_dberr == dberr) {
fprintf(stdout, "OK: anticipated error %d (%s) arrived\n", dberr, dberrstr);
*pexpected_dberr = 0;
return INT_CANCEL;
}
}
fflush(stdout);
fprintf(stderr,
"DB-LIBRARY error (dberr %d (severity %d): \"%s\"; oserr %d: \"%s\")\n",
dberr, severity, dberrstr ? dberrstr : "(null)", oserr, oserrstr ? oserrstr : "(null)");
fflush(stderr);
/*
* If the dbprocess is dead or the dbproc is a NULL pointer and
* we are not in the middle of logging in, then we need to exit.
* We can't do anything from here on out anyway.
* It's OK to end up here in response to a dbconvert() that
* resulted in overflow, so don't exit in that case.
*/
if ((dbproc == NULL) || DBDEAD(dbproc)) {
if (dberr != SYBECOFL) {
exit(255);
}
}
if (severity) {
fprintf(stderr, "error: no unanticipated errors allowed in unit tests\n");
exit(EXIT_FAILURE);
}
return INT_CANCEL;
}
int error_handler(DBPROCESS *dbproc, int severity, int dberr,
int oserr, char *dberrstr, char *oserrstr)
{
pdo_dblib_err *einfo;
char *state = "HY000";
TSRMLS_FETCH();
if(dbproc) {
einfo = (pdo_dblib_err*)dbgetuserdata(dbproc);
if (!einfo) einfo = &DBLIB_G(err);
} else {
einfo = &DBLIB_G(err);
}
einfo->severity = severity;
einfo->oserr = oserr;
einfo->dberr = dberr;
if (einfo->oserrstr) {
efree(einfo->oserrstr);
}
if (einfo->dberrstr) {
efree(einfo->dberrstr);
}
if (oserrstr) {
einfo->oserrstr = estrdup(oserrstr);
} else {
einfo->oserrstr = NULL;
}
if (dberrstr) {
einfo->dberrstr = estrdup(dberrstr);
} else {
einfo->dberrstr = NULL;
}
switch (dberr) {
case SYBESEOF:
case SYBEFCON: state = "01002"; break;
case SYBEMEM: state = "HY001"; break;
case SYBEPWD: state = "28000"; break;
}
strcpy(einfo->sqlstate, state);
#if 0
php_error_docref(NULL TSRMLS_CC, E_WARNING,
"dblib error: %d %s (severity %d)",
dberr, dberrstr, severity);
#endif
return INT_CANCEL;
}
int pdo_dblib_error_handler(DBPROCESS *dbproc, int severity, int dberr,
int oserr, char *dberrstr, char *oserrstr)
{
pdo_dblib_err *einfo;
char *state = "HY000";
if(dbproc) {
einfo = (pdo_dblib_err*)dbgetuserdata(dbproc);
if (!einfo) einfo = &DBLIB_G(err);
} else {
einfo = &DBLIB_G(err);
}
einfo->severity = severity;
einfo->oserr = oserr;
einfo->dberr = dberr;
if (einfo->oserrstr) {
efree(einfo->oserrstr);
}
if (einfo->dberrstr) {
efree(einfo->dberrstr);
}
if (oserrstr) {
einfo->oserrstr = estrdup(oserrstr);
} else {
einfo->oserrstr = NULL;
}
if (dberrstr) {
einfo->dberrstr = estrdup(dberrstr);
} else {
einfo->dberrstr = NULL;
}
switch (dberr) {
case SYBESEOF:
case SYBEFCON: state = "01002"; break;
case SYBEMEM: state = "HY001"; break;
case SYBEPWD: state = "28000"; break;
}
strcpy(einfo->sqlstate, state);
return INT_CANCEL;
}
int pdo_dblib_msg_handler(DBPROCESS *dbproc, DBINT msgno, int msgstate,
int severity, char *msgtext, char *srvname, char *procname, DBUSMALLINT line)
{
pdo_dblib_err *einfo;
if (severity) {
einfo = (pdo_dblib_err*)dbgetuserdata(dbproc);
if (!einfo) {
einfo = &DBLIB_G(err);
}
if (einfo->lastmsg) {
efree(einfo->lastmsg);
}
einfo->lastmsg = estrdup(msgtext);
}
return 0;
}
static int
ngx_dbd_freetds_msg_handler(DBPROCESS *db, DBINT msgno, int msgstate,
int severity, char *msgtext, char *srvname, char *procname,
DBUSMALLINT line)
{
ngx_log_t *log;
ngx_dbd_t *dbd;
dbd = dbgetuserdata(db);
if (dbd != NULL) {
log = dbd->log;
} else {
log = ngx_cycle->log;
}
if (msgtext == NULL) {
msgtext = "";
}
if (srvname == NULL) {
srvname = "";
}
if (procname == NULL) {
procname = "";
}
/* TODO */
ngx_log_debug7(NGX_LOG_DEBUG_CORE, log, 0,
"msgno: %d, msgstate: %d, severity: %d, "
"msgtext: %s, srvname: %s, procname: %s, line: %d",
msgno, msgstate, severity, msgtext, srvname, procname, line);
return 0;
}
static VALUE rb_tinytds_result_each(int argc, VALUE * argv, VALUE self) {
/* Local Vars */
VALUE qopts, opts, block;
ID timezone;
int symbolize_keys = 0, as_array = 0, cache_rows = 0, first = 0, empty_sets = 0;
tinytds_client_userdata *userdata;
GET_RESULT_WRAPPER(self);
userdata = (tinytds_client_userdata *)dbgetuserdata(rwrap->client);
/* Merge Options Hash To Query Options. Populate Opts & Block Var. */
qopts = rb_iv_get(self, "@query_options");
if (rb_scan_args(argc, argv, "01&", &opts, &block) == 1)
qopts = rb_funcall(qopts, intern_merge, 1, opts);
rb_iv_set(self, "@query_options", qopts);
/* Locals From Options */
if (rb_hash_aref(qopts, sym_first) == Qtrue)
first = 1;
if (rb_hash_aref(qopts, sym_symbolize_keys) == Qtrue)
symbolize_keys = 1;
if (rb_hash_aref(qopts, sym_as) == sym_array)
as_array = 1;
if (rb_hash_aref(qopts, sym_cache_rows) == Qtrue)
cache_rows = 1;
if (rb_hash_aref(qopts, sym_timezone) == sym_local) {
timezone = intern_local;
} else if (rb_hash_aref(qopts, sym_timezone) == sym_utc) {
timezone = intern_utc;
} else {
rb_warn(":timezone option must be :utc or :local - defaulting to :local");
timezone = intern_local;
}
if (rb_hash_aref(qopts, sym_empty_sets) == Qtrue)
empty_sets = 1;
/* Make The Results Or Yield Existing */
if (NIL_P(rwrap->results)) {
RETCODE dbsqlok_rc, dbresults_rc;
rwrap->results = rb_ary_new();
dbsqlok_rc = rb_tinytds_result_ok_helper(rwrap->client);
dbresults_rc = rb_tinytds_result_dbresults_retcode(self);
while ((dbsqlok_rc == SUCCEED) && (dbresults_rc == SUCCEED)) {
int has_rows = (DBROWS(rwrap->client) == SUCCEED) ? 1 : 0;
if (has_rows || empty_sets || (rwrap->number_of_results == 0))
rb_tinytds_result_fields(self);
if ((has_rows || empty_sets) && rwrap->number_of_fields > 0) {
/* Create rows for this result set. */
unsigned long rowi = 0;
VALUE result = rb_ary_new();
while (nogvl_dbnextrow(rwrap->client) != NO_MORE_ROWS) {
VALUE row = rb_tinytds_result_fetch_row(self, timezone, symbolize_keys, as_array);
if (cache_rows)
rb_ary_store(result, rowi, row);
if (!NIL_P(block))
rb_yield(row);
if (first) {
dbcanquery(rwrap->client);
userdata->dbcancel_sent = 1;
}
rowi++;
}
rwrap->number_of_rows = rowi;
/* Store the result. */
if (cache_rows) {
if (rwrap->number_of_results == 0) {
rwrap->results = result;
} else if (rwrap->number_of_results == 1) {
VALUE multi_resultsets = rb_ary_new();
rb_ary_store(multi_resultsets, 0, rwrap->results);
rb_ary_store(multi_resultsets, 1, result);
rwrap->results = multi_resultsets;
} else {
rb_ary_store(rwrap->results, rwrap->number_of_results, result);
}
}
// If we find results increment the counter that helpers use and setup the next loop.
rwrap->number_of_results = rwrap->number_of_results + 1;
dbresults_rc = rb_tinytds_result_dbresults_retcode(self);
rb_ary_store(rwrap->fields_processed, rwrap->number_of_results, Qnil);
} else {
// If we do not find results, side step the rb_tinytds_result_dbresults_retcode helper and
// manually populate its memoized array while nullifing any memoized fields too before loop.
dbresults_rc = nogvl_dbresults(rwrap->client);
rb_ary_store(rwrap->dbresults_retcodes, rwrap->number_of_results, INT2FIX(dbresults_rc));
rb_ary_store(rwrap->fields_processed, rwrap->number_of_results, Qnil);
}
}
if (dbresults_rc == FAIL)
rb_warn("TinyTDS: Something in the dbresults() while loop set the return code to FAIL.\n");
userdata->dbsql_sent = 0;
} else if (!NIL_P(block)) {
unsigned long i;
for (i = 0; i < rwrap->number_of_rows; i++) {
rb_yield(rb_ary_entry(rwrap->results, i));
}
}
return rwrap->results;
}
int
syb_msg_handler(DBPROCESS * dbproc, DBINT msgno, int msgstate, int severity, char *msgtext, char *srvname, char *procname, int line)
{
int *pexpected_msgno;
/*
* Check for "database changed", or "language changed" messages from
* the client. If we get one of these, then we need to pull the
* name of the database or charset from the message and set the
* appropriate variable.
*/
if (msgno == 5701 || /* database context change */
msgno == 5703 || /* language changed */
msgno == 5704) { /* charset changed */
/* fprintf( stderr, "msgno = %d: %s\n", msgno, msgtext ) ; */
return 0;
}
/*
* If the user data indicates this is an expected error message (because we're testing the
* error propogation, say) then indicate this message was anticipated.
*/
if (dbproc != NULL) {
pexpected_msgno = (int *) dbgetuserdata(dbproc);
if (pexpected_msgno && *pexpected_msgno == msgno) {
fprintf(stdout, "OK: anticipated message arrived: %d %s\n", (int) msgno, msgtext);
*pexpected_msgno = 0;
return 0;
}
}
/*
* If the severity is something other than 0 or the msg number is
* 0 (user informational messages).
*/
fflush(stdout);
if (severity >= 0 || msgno == 0) {
/*
* If the message was something other than informational, and
* the severity was greater than 0, then print information to
* stderr with a little pre-amble information.
*/
if (msgno > 0 && severity > 0) {
fprintf(stderr, "Msg %d, Level %d, State %d\n", (int) msgno, (int) severity, (int) msgstate);
fprintf(stderr, "Server '%s'", srvname);
if (procname != NULL && *procname != '\0')
fprintf(stderr, ", Procedure '%s'", procname);
if (line > 0)
fprintf(stderr, ", Line %d", line);
fprintf(stderr, "\n");
fprintf(stderr, "%s\n", msgtext);
fflush(stderr);
} else {
/*
* Otherwise, it is just an informational (e.g. print) message
* from the server, so send it to stdout.
*/
fprintf(stdout, "%s\n", msgtext);
fflush(stdout);
severity = 0;
}
}
if (severity) {
fprintf(stderr, "exit: no unanticipated messages allowed in unit tests\n");
exit(EXIT_FAILURE);
}
return 0;
}
