std::string StatementException::compose(const std::string& text, MYSQL_STMT* h, const std::string& stmt)
{
std::string str;
str += "[Comment]: ";
str += text;
if (h != 0)
{
str += "\t[mysql_stmt_error]: ";
str += mysql_stmt_error(h);
str += "\t[mysql_stmt_errno]: ";
char buff[30];
sprintf(buff, "%d", mysql_stmt_errno(h));
str += buff;
str += "\t[mysql_stmt_sqlstate]: ";
str += mysql_stmt_sqlstate(h);
}
if (stmt.length() > 0)
{
str += "\t[statemnt]: ";
str += stmt;
}
return str;
}
SqlException::SqlException(MYSQL_STMT *stmt, const StringRef& initialMessage)
:std::exception(initialMessage.c_str())
{
mErrno = mysql_stmt_errno(stmt);
mErrorMessage = mysql_stmt_error(stmt);
mSqlState = mysql_stmt_sqlstate(stmt);
}
void rb_raise_mysql2_stmt_error(mysql_stmt_wrapper *stmt_wrapper) {
VALUE e;
GET_CLIENT(stmt_wrapper->client);
VALUE rb_error_msg = rb_str_new2(mysql_stmt_error(stmt_wrapper->stmt));
VALUE rb_sql_state = rb_tainted_str_new2(mysql_stmt_sqlstate(stmt_wrapper->stmt));
#ifdef HAVE_RUBY_ENCODING_H
rb_encoding *conn_enc;
conn_enc = rb_to_encoding(wrapper->encoding);
rb_encoding *default_internal_enc = rb_default_internal_encoding();
rb_enc_associate(rb_error_msg, conn_enc);
rb_enc_associate(rb_sql_state, conn_enc);
if (default_internal_enc) {
rb_error_msg = rb_str_export_to_enc(rb_error_msg, default_internal_enc);
rb_sql_state = rb_str_export_to_enc(rb_sql_state, default_internal_enc);
}
#endif
e = rb_funcall(cMysql2Error, intern_new_with_args, 4,
rb_error_msg,
LONG2FIX(wrapper->server_version),
UINT2NUM(mysql_stmt_errno(stmt_wrapper->stmt)),
rb_sql_state);
rb_exc_raise(e);
}
void MADB_SetNativeError(MADB_Error *Error, SQLSMALLINT HandleType, void *Ptr)
{
char *Sqlstate= NULL, *Errormsg= NULL;
int NativeError= 0;
switch (HandleType) {
case SQL_HANDLE_DBC:
Sqlstate= (char *)mysql_sqlstate((MYSQL *)Ptr);
Errormsg= (char *)mysql_error((MYSQL *)Ptr);
NativeError= mysql_errno((MYSQL *)Ptr);
break;
case SQL_HANDLE_STMT:
Sqlstate= (char *)mysql_stmt_sqlstate((MYSQL_STMT *)Ptr);
Errormsg= (char *)mysql_stmt_error((MYSQL_STMT *)Ptr);
NativeError= mysql_stmt_errno((MYSQL_STMT *)Ptr);
break;
}
if ((NativeError == 2013 || NativeError == 2006) && strcmp(Sqlstate, "HY000") == 0)
Sqlstate= "08S01";
Error->ReturnValue= SQL_ERROR;
if (Errormsg)
{
strcpy_s(Error->SqlErrorMsg + Error->PrefixLen, SQL_MAX_MESSAGE_LENGTH + 1 - Error->PrefixLen, Errormsg);
}
if (Sqlstate)
strcpy_s(Error->SqlState, SQLSTATE_LENGTH + 1, Sqlstate);
Error->NativeError= NativeError;
if (Error->SqlState[0] == '0')
Error->ReturnValue= (Error->SqlState[1] == '0') ? SQL_SUCCESS :
(Error->SqlState[1] == '1') ? SQL_SUCCESS_WITH_INFO : SQL_ERROR;
}
void DBManager::print_stmt_error (char *message) {
fprintf (stderr, "%s\n", message);
if (m_stmt != NULL) {
fprintf (stderr, "Error %u (%s): %s\n",
mysql_stmt_errno (m_stmt),
mysql_stmt_sqlstate (m_stmt),
mysql_stmt_error (m_stmt));
}
}
void print_mysql_stmt_error (MYSQL_STMT *stmt, const std::string &mensaje)
{
std::cerr << mensaje << std::endl;
if (stmt != NULL) {
std::cerr << "Error " << mysql_stmt_errno (stmt);
std::cerr << "(" << mysql_stmt_sqlstate (stmt);
std::cerr << "): " << mysql_stmt_error (stmt) << std::endl;
}
}
static void
print_stmt_error (MYSQL_STMT *stmt, char *message)
{
fprintf (stderr, "%s\n", message);
if (stmt != NULL)
{
fprintf (stderr, "Error %u (%s): %s\n",
mysql_stmt_errno (stmt),
mysql_stmt_sqlstate (stmt),
mysql_stmt_error (stmt));
}
}
void print_stmt_error(MYSQL_STMT *stmt, const char *message, const char* file, int line)
{
fprintf(stderr,"%s\n", message);
if (stmt != NULL)
{
fprintf(stderr,"%s:%d: Error %u (%s): %s\n",
file, line,
mysql_stmt_errno(stmt),
mysql_stmt_sqlstate(stmt),
mysql_stmt_error(stmt));
}
}
static int test_bug16143(MYSQL *mysql)
{
MYSQL_STMT *stmt;
stmt= mysql_stmt_init(mysql);
FAIL_IF(!stmt, mysql_error(mysql));
/* Check mysql_stmt_sqlstate return "no error" */
FAIL_UNLESS(strcmp(mysql_stmt_sqlstate(stmt), "00000") == 0, "Expected SQLstate 000000");
mysql_stmt_close(stmt);
return OK;
}
/*
* convenience function to log mysql statement errors
*/
static void
netsnmp_sql_stmt_error (MYSQL_STMT *stmt, const char *message)
{
u_int err = mysql_errno(_sql.conn);
snmp_log(LOG_ERR, "%s\n", message);
if (stmt) {
snmp_log(LOG_ERR, "SQL Error %u (%s): %s\n",
mysql_stmt_errno(stmt), mysql_stmt_sqlstate(stmt),
mysql_stmt_error(stmt));
}
if (CR_SERVER_GONE_ERROR == err)
netsnmp_sql_disconnected();
}
/* AString SQLState (); */
NS_IMETHODIMP jxMySQL50Statement::SQLState(nsAString & _retval)
{
if (mConnection == nsnull)
{
SET_ERROR_RETURN (JX_MYSQL50_ERROR_NOT_CONNECTED);
}
if (mSTMT == nsnull)
{
SET_ERROR_RETURN (JX_MYSQL50_ERROR_STMT_NULL);
}
_retval.Assign(NS_ConvertUTF8toUTF16(mysql_stmt_sqlstate(mSTMT)));
return NS_OK;
}
/* {{{ property stmt_error_list_read */
static zval *stmt_error_list_read(mysqli_object *obj, zval *retval)
{
MY_STMT * stmt;
CHECK_STATUS(MYSQLI_STATUS_INITIALIZED);
stmt = (MY_STMT *)((MYSQLI_RESOURCE *)(obj->ptr))->ptr;
array_init(retval);
if (stmt && stmt->stmt) {
#if defined(MYSQLI_USE_MYSQLND)
if (stmt->stmt->data && stmt->stmt->data->error_info->error_list) {
MYSQLND_ERROR_LIST_ELEMENT * message;
zend_llist_position pos;
for (message = (MYSQLND_ERROR_LIST_ELEMENT *) zend_llist_get_first_ex(stmt->stmt->data->error_info->error_list, &pos);
message;
message = (MYSQLND_ERROR_LIST_ELEMENT *) zend_llist_get_next_ex(stmt->stmt->data->error_info->error_list, &pos))
{
zval single_error;
array_init(&single_error);
add_assoc_long_ex(&single_error, "errno", sizeof("errno") - 1, message->error_no);
add_assoc_string_ex(&single_error, "sqlstate", sizeof("sqlstate") - 1, message->sqlstate);
add_assoc_string_ex(&single_error, "error", sizeof("error") - 1, message->error);
add_next_index_zval(retval, &single_error);
}
}
#else
if (mysql_stmt_errno(stmt->stmt)) {
zval single_error;
array_init(&single_error);
add_assoc_long_ex(&single_error, "errno", sizeof("errno") - 1, mysql_stmt_errno(stmt->stmt));
add_assoc_string_ex(&single_error, "sqlstate", sizeof("sqlstate") - 1, mysql_stmt_sqlstate(stmt->stmt));
add_assoc_string_ex(&single_error, "error", sizeof("error") - 1, mysql_stmt_error(stmt->stmt));
add_next_index_zval(retval, &single_error);
}
#endif
}
return retval;
}
static int test_ps_client_errors(MYSQL *mysql)
{
int rc;
MYSQL_STMT *stmt;
char *query= "DROP TABLE test_non_exists";
rc= mysql_query(mysql, "DROP TABLE if exists test_non_exists");
check_mysql_rc(rc, mysql);
stmt= mysql_stmt_init(mysql);
rc= mysql_stmt_prepare(stmt, query, strlen(query));
FAIL_IF(rc, mysql_stmt_error(stmt));
rc= mysql_stmt_execute(stmt);
FAIL_IF(!rc, mysql_stmt_error(stmt));
FAIL_IF(!mysql_stmt_errno(stmt), "Error expected");
FAIL_IF(!strlen(mysql_stmt_error(stmt)), "Empty errormsg");
FAIL_IF(strcmp(mysql_stmt_sqlstate(stmt), "00000") == 0, "Invalid SQLstate");
mysql_stmt_close(stmt);
return OK;
}
/* {{{ _pdo_mysql_error */
int _pdo_mysql_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt, const char *file, int line TSRMLS_DC)
{
pdo_mysql_db_handle *H = (pdo_mysql_db_handle *)dbh->driver_data;
pdo_error_type *pdo_err;
pdo_mysql_error_info *einfo;
pdo_mysql_stmt *S = NULL;
PDO_DBG_ENTER("_pdo_mysql_error");
PDO_DBG_INF_FMT("file=%s line=%d", file, line);
if (stmt) {
S = (pdo_mysql_stmt*)stmt->driver_data;
pdo_err = &stmt->error_code;
einfo = &S->einfo;
} else {
pdo_err = &dbh->error_code;
einfo = &H->einfo;
}
if (S && S->stmt) {
einfo->errcode = mysql_stmt_errno(S->stmt);
} else {
einfo->errcode = mysql_errno(H->server);
}
einfo->file = file;
einfo->line = line;
if (einfo->errmsg) {
pefree(einfo->errmsg, dbh->is_persistent);
einfo->errmsg = NULL;
}
if (einfo->errcode) {
if (einfo->errcode == 2014) {
einfo->errmsg = pestrdup(
"Cannot execute queries while other unbuffered queries are active. "
"Consider using PDOStatement::fetchAll(). Alternatively, if your code "
"is only ever going to run against mysql, you may enable query "
"buffering by setting the PDO::MYSQL_ATTR_USE_BUFFERED_QUERY attribute.",
dbh->is_persistent);
} else if (einfo->errcode == 2057) {
einfo->errmsg = pestrdup(
"A stored procedure returning result sets of different size was called. "
"This is not supported by libmysql",
dbh->is_persistent);
} else {
einfo->errmsg = pestrdup(mysql_error(H->server), dbh->is_persistent);
}
} else { /* no error */
strcpy(*pdo_err, PDO_ERR_NONE);
PDO_DBG_RETURN(0);
}
if (S && S->stmt) {
strcpy(*pdo_err, mysql_stmt_sqlstate(S->stmt));
} else {
strcpy(*pdo_err, mysql_sqlstate(H->server));
}
if (!dbh->methods) {
PDO_DBG_INF("Throwing exception");
zend_throw_exception_ex(php_pdo_get_exception(), einfo->errcode TSRMLS_CC, "SQLSTATE[%s] [%d] %s",
*pdo_err, einfo->errcode, einfo->errmsg);
}
PDO_DBG_RETURN(einfo->errcode);
}
DatabaseException::DatabaseException(MYSQL_STMT *stmt, const std::string &initialMessage) {
_errno = mysql_stmt_errno(stmt);
_errorMessage = mysql_stmt_error(stmt);
_sqlState = mysql_stmt_sqlstate(stmt);
_initialMessage = initialMessage;
}
