static VALUE rb_raise_mysql2_error(MYSQL *client) {
VALUE e = rb_exc_new2(cMysql2Error, mysql_error(client));
rb_funcall(e, rb_intern("error_number="), 1, INT2NUM(mysql_errno(client)));
rb_funcall(e, rb_intern("sql_state="), 1, rb_tainted_str_new2(mysql_sqlstate(client)));
rb_exc_raise(e);
return Qnil;
}
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;
}
static void raise_error(VALUE self, MYSQL *db, VALUE query) {
VALUE exception;
const char *exception_type = "SQLError";
char *mysql_error_message = (char *)mysql_error(db);
int mysql_error_code = mysql_errno(db);
struct errcodes *errs;
for (errs = errors; errs->error_name; errs++) {
if(errs->error_no == mysql_error_code) {
exception_type = errs->exception;
break;
}
}
VALUE uri = rb_funcall(rb_iv_get(self, "@connection"), rb_intern("to_s"), 0);
exception = rb_funcall(CONST_GET(mDO, exception_type), ID_NEW, 5,
rb_str_new2(mysql_error_message),
INT2NUM(mysql_error_code),
rb_str_new2(mysql_sqlstate(db)),
query,
uri);
rb_exc_raise(exception);
}
SqlException::SqlException(MYSQL *db, const StringRef& initialMessage)
:std::exception(initialMessage.c_str())
{
mErrno = mysql_errno(db);
mErrorMessage = mysql_error(db);
mSqlState = mysql_sqlstate(db);
}
static VALUE rb_raise_mysql2_error(mysql_client_wrapper *wrapper) {
VALUE rb_error_msg = rb_str_new2(mysql_error(wrapper->client));
VALUE rb_sql_state = rb_tainted_str_new2(mysql_sqlstate(wrapper->client));
VALUE e;
#ifdef HAVE_RUBY_ENCODING_H
if (wrapper->server_version < 50500) {
/* MySQL < 5.5 uses mixed encoding, just call it binary. */
int err_enc = rb_ascii8bit_encindex();
rb_enc_associate_index(rb_error_msg, err_enc);
rb_enc_associate_index(rb_sql_state, err_enc);
} else {
/* MySQL >= 5.5 uses UTF-8 errors internally and converts them to the connection encoding. */
rb_encoding *default_internal_enc = rb_default_internal_encoding();
rb_encoding *conn_enc = rb_to_encoding(wrapper->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_exc_new3(cMysql2Error, rb_error_msg);
rb_funcall(e, intern_error_number_eql, 1, UINT2NUM(mysql_errno(wrapper->client)));
rb_funcall(e, intern_sql_state_eql, 1, rb_sql_state);
rb_exc_raise(e);
return Qnil;
}
void show_error(MYSQL *mysql)
{
printf("Error(%d) [%s] \"%s\"", mysql_errno(mysql),
mysql_sqlstate(mysql),
mysql_error(mysql));
mysql_close(mysql);
exit(-1);
}
static void print_error (DB_HANDLE conn, char *message)
{
fprintf (stderr, "%s\n", message);
if (conn != NULL)
{
fprintf (stderr, "Error %u (%s): %s\n",
mysql_errno (conn), mysql_sqlstate (conn), mysql_error (conn));
}
}
bool Connection::GetError(char* Buffer, unsigned long Length)
{
unsigned int err = mysql_errno(MySQL);
if (err != 0)
{
snprintf(Buffer, Length, "Error(%d) [%s] \"%s\"\n", mysql_errno(MySQL), mysql_sqlstate(MySQL), mysql_error(MySQL));
}
return err != 0;
}
void print_mysql_error (MYSQL *my_con, const std::string &mensaje)
{
std::cerr << mensaje << std::endl;
if (my_con != NULL) {
std::cerr << "Error " << mysql_errno (my_con);
std::cerr << "(" << mysql_sqlstate (my_con);
std::cerr << "): " << mysql_error (my_con) << std::endl;
}
}
int
try_stmt_execute(MYSQL_STMT *mysql_stmt)
{
int ret = mysql_stmt_execute(mysql_stmt);
if (ret) {
printf("\n%d, %s, %s\n", mysql_errno(mysql), mysql_sqlstate(mysql), mysql_error(mysql) );
mysql_rollback(mysql);
}
return ret;
}
void do_mysql_raise_error(VALUE self, MYSQL *db, VALUE query) {
int errnum = mysql_errno(db);
const char *message = mysql_error(db);
VALUE sql_state = Qnil;
#ifdef HAVE_MYSQL_SQLSTATE
sql_state = rb_str_new2(mysql_sqlstate(db));
#endif
data_objects_raise_error(self, do_mysql_errors, errnum, message, query, sql_state);
}
/*
* Connects to MySQL.
*/
static int connect (lua_State *L) {
mysql_rec *m;
const char *host, *user, *passwd, *db, *unix_socket, *charset;
int port;
luaL_checktype(L, 1, LUA_TTABLE);
host = get_string_field(L, 1, "host", NULL);
user = get_string_field(L, 1, "user", NULL);
passwd = get_string_field(L, 1, "password", NULL);
db = get_string_field(L, 1, "database", NULL);
port = get_int_field(L, 1, "port", 0);
unix_socket = get_string_field(L, 1, "unix_socket", NULL);
charset = get_string_field(L, 1, "charset", NULL);
m = (mysql_rec *) lua_newuserdata(L, sizeof(mysql_rec));
memset(m, 0, sizeof(mysql_rec));
#ifdef _REENTRANT
if (pthread_mutex_lock(&lock) != 0) {
lua_pushliteral(L, "Error acquiring MySQL lock");
lua_error(L);
}
#endif
m->mysql = mysql_init(NULL);
#ifdef _REENTRANT
if (pthread_mutex_unlock(&lock) != 0) {
lua_pushliteral(L, "Error releasing MySQL lock");
lua_error(L);
}
#endif
if (!m->mysql) {
lua_pushliteral(L, "MySQL error: out of memory");
lua_error(L);
}
if (!mysql_real_connect(m->mysql, host, user, passwd, db, port,
unix_socket, 0)) {
lua_pushfstring(L, "MySQL error %d (%s): %s",
mysql_errno(m->mysql), mysql_sqlstate(m->mysql),
mysql_error(m->mysql));
mysql_close(m->mysql);
lua_error(L);
}
if (charset) {
if (mysql_set_character_set(m->mysql, charset)) {
error(L, m);
}
}
luaL_getmetatable(L, IS_MYSQL_METATABLE);
lua_setmetatable(L, -2);
return 1;
}
/** This function and the kernel of a few other routines cut and pasted from
_MySQL (Third Edition)_, Paul DuBois, Sams Developer's Library, March, 2005
*/
static void print_error (MYSQL *conn, char *message) {
if (apop_opts.verbose < 0)
return;
fprintf (stderr, "%s\n", message);
if (conn != NULL) {
#if MYSQL_VERSION_ID >= 40101
fprintf (stderr, "Error %u (%s): %s\n",
mysql_errno (conn), mysql_sqlstate(conn), mysql_error (conn));
#else
fprintf (stderr, "Error %u: %s\n", mysql_errno (conn), mysql_error (conn));
#endif
}
}
static int test_client_errors(MYSQL *mysql)
{
int rc;
rc= mysql_query(mysql, "DROP TABLE if exists test_non_exists");
check_mysql_rc(rc, mysql);
rc= mysql_query(mysql, "DROP TABLE test_non_exists");
FAIL_IF(!rc, "Error expected");
FAIL_IF(!mysql_errno(mysql), "Error expected");
FAIL_IF(!strlen(mysql_error(mysql)), "Empty errormsg");
FAIL_IF(strcmp(mysql_sqlstate(mysql), "00000") == 0, "Invalid SQLstate");
return OK;
}
static VALUE rb_raise_mysql2_error(mysql_client_wrapper *wrapper) {
VALUE rb_error_msg = rb_str_new2(mysql_error(wrapper->client));
VALUE rb_sql_state = rb_tainted_str_new2(mysql_sqlstate(wrapper->client));
VALUE e;
#ifdef HAVE_RUBY_ENCODING_H
rb_enc_associate(rb_error_msg, rb_utf8_encoding());
rb_enc_associate(rb_sql_state, rb_usascii_encoding());
#endif
e = rb_funcall(cMysql2Error, rb_intern("new"), 2, rb_error_msg, LONG2FIX(wrapper->server_version));
rb_funcall(e, intern_error_number_eql, 1, UINT2NUM(mysql_errno(wrapper->client)));
rb_funcall(e, intern_sql_state_eql, 1, rb_sql_state);
rb_exc_raise(e);
return Qnil;
}
std::string ConnectionException::compose(const std::string& text, MYSQL* h)
{
std::string str;
str += "[Comment]: ";
str += text;
str += "\t[mysql_error]: ";
str += mysql_error(h);
str += "\t[mysql_errno]: ";
char buff[30];
sprintf(buff, "%d", mysql_errno(h));
str += buff;
str += "\t[mysql_sqlstate]: ";
str += mysql_sqlstate(h);
return str;
}
/*
* convenience function to log mysql errors
*/
static void
netsnmp_sql_error(const char *message)
{
u_int err = mysql_errno(_sql.conn);
snmp_log(LOG_ERR, "%s\n", message);
if (_sql.conn != NULL) {
#if MYSQL_VERSION_ID >= 40101
snmp_log(LOG_ERR, "Error %u (%s): %s\n",
err, mysql_sqlstate(_sql.conn), mysql_error(_sql.conn));
#else
snmp(LOG_ERR, "Error %u: %s\n",
mysql_errno(_sql.conn), mysql_error(_sql.conn));
#endif
}
if (CR_SERVER_GONE_ERROR == err)
netsnmp_sql_disconnected();
}
static VALUE rb_raise_mysql2_error(mysql_client_wrapper *wrapper) {
VALUE rb_error_msg = rb_str_new2(mysql_error(wrapper->client));
VALUE rb_sql_state = rb_tainted_str_new2(mysql_sqlstate(wrapper->client));
VALUE e;
#ifdef HAVE_RUBY_ENCODING_H
rb_enc_associate(rb_error_msg, rb_utf8_encoding());
rb_enc_associate(rb_sql_state, rb_usascii_encoding());
#endif
e = rb_funcall(cMysql2Error, intern_new_with_args, 4,
rb_error_msg,
LONG2FIX(wrapper->server_version),
UINT2NUM(mysql_errno(wrapper->client)),
rb_sql_state);
rb_exc_raise(e);
}
static VALUE rb_raise_mysql2_error(mysql_client_wrapper *wrapper) {
VALUE rb_error_msg = rb_str_new2(mysql_error(wrapper->client));
VALUE rb_sql_state = rb_tainted_str_new2(mysql_sqlstate(wrapper->client));
#ifdef HAVE_RUBY_ENCODING_H
rb_encoding *default_internal_enc = rb_default_internal_encoding();
rb_encoding *conn_enc = rb_to_encoding(wrapper->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
VALUE e = rb_exc_new3(cMysql2Error, rb_error_msg);
rb_funcall(e, intern_error_number_eql, 1, UINT2NUM(mysql_errno(wrapper->client)));
rb_funcall(e, intern_sql_state_eql, 1, rb_sql_state);
rb_exc_raise(e);
return Qnil;
}
/* {{{ property link_error_list_read */
static zval *link_error_list_read(mysqli_object *obj, zval *retval)
{
MY_MYSQL *mysql;
CHECK_STATUS(MYSQLI_STATUS_VALID);
mysql = (MY_MYSQL *)((MYSQLI_RESOURCE *)(obj->ptr))->ptr;
array_init(retval);
if (mysql) {
#if defined(MYSQLI_USE_MYSQLND)
if (mysql->mysql->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(mysql->mysql->data->error_info->error_list, &pos);
message;
message = (MYSQLND_ERROR_LIST_ELEMENT *) zend_llist_get_next_ex(mysql->mysql->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_errno(mysql->mysql)) {
zval single_error;
array_init(&single_error);
add_assoc_long_ex(&single_error, "errno", sizeof("errno") - 1, mysql_errno(mysql->mysql));
add_assoc_string_ex(&single_error, "sqlstate", sizeof("sqlstate") - 1, mysql_sqlstate(mysql->mysql));
add_assoc_string_ex(&single_error, "error", sizeof("error") - 1, mysql_error(mysql->mysql));
add_next_index_zval(retval, &single_error);
}
#endif
}
return retval;
}
/*
* Raises a MySQL error in Lua.
*/
static void error (lua_State *L, mysql_rec *m) {
luaL_error(L, "MySQL error %d (%s): %s", mysql_errno(m->mysql),
mysql_sqlstate(m->mysql), mysql_error(m->mysql));
}
static PyObject* wsql_connection_get_sqlstate(wsql_connection *self, void* closure)
{
CHECK_CONNECTION(self, NULL);
return PyString_FromString(mysql_sqlstate(&(self->connection)));
}
/* {{{ _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);
}
bool
DbUtil::runQuery(const char* sql,
const Properties& args,
SqlResultSet& rows){
rows.clear();
if (!isConnected())
return false;
g_debug << "runQuery: " << endl
<< " sql: '" << sql << "'" << endl;
MYSQL_STMT *stmt= mysql_stmt_init(m_mysql);
if (mysql_stmt_prepare(stmt, sql, strlen(sql)))
{
g_err << "Failed to prepare: " << mysql_error(m_mysql) << endl;
return false;
}
uint params= mysql_stmt_param_count(stmt);
MYSQL_BIND bind_param[params];
bzero(bind_param, sizeof(bind_param));
for(uint i= 0; i < mysql_stmt_param_count(stmt); i++)
{
BaseString name;
name.assfmt("%d", i);
// Parameters are named 0, 1, 2...
if (!args.contains(name.c_str()))
{
g_err << "param " << i << " missing" << endl;
assert(false);
}
PropertiesType t;
Uint32 val_i;
const char* val_s;
args.getTypeOf(name.c_str(), &t);
switch(t) {
case PropertiesType_Uint32:
args.get(name.c_str(), &val_i);
bind_param[i].buffer_type= MYSQL_TYPE_LONG;
bind_param[i].buffer= (char*)&val_i;
g_debug << " param" << name.c_str() << ": " << val_i << endl;
break;
case PropertiesType_char:
args.get(name.c_str(), &val_s);
bind_param[i].buffer_type= MYSQL_TYPE_STRING;
bind_param[i].buffer= (char*)val_s;
bind_param[i].buffer_length= strlen(val_s);
g_debug << " param" << name.c_str() << ": " << val_s << endl;
break;
default:
assert(false);
break;
}
}
if (mysql_stmt_bind_param(stmt, bind_param))
{
g_err << "Failed to bind param: " << mysql_error(m_mysql) << endl;
mysql_stmt_close(stmt);
return false;
}
if (mysql_stmt_execute(stmt))
{
g_err << "Failed to execute: " << mysql_error(m_mysql) << endl;
mysql_stmt_close(stmt);
return false;
}
/*
Update max_length, making it possible to know how big
buffers to allocate
*/
my_bool one= 1;
mysql_stmt_attr_set(stmt, STMT_ATTR_UPDATE_MAX_LENGTH, (void*) &one);
if (mysql_stmt_store_result(stmt))
{
g_err << "Failed to store result: " << mysql_error(m_mysql) << endl;
mysql_stmt_close(stmt);
return false;
}
uint row= 0;
MYSQL_RES* res= mysql_stmt_result_metadata(stmt);
if (res != NULL)
{
MYSQL_FIELD *fields= mysql_fetch_fields(res);
uint num_fields= mysql_num_fields(res);
MYSQL_BIND bind_result[num_fields];
bzero(bind_result, sizeof(bind_result));
for (uint i= 0; i < num_fields; i++)
{
if (is_int_type(fields[i].type)){
bind_result[i].buffer_type= MYSQL_TYPE_LONG;
bind_result[i].buffer= malloc(sizeof(int));
}
else
{
uint max_length= fields[i].max_length + 1;
bind_result[i].buffer_type= MYSQL_TYPE_STRING;
bind_result[i].buffer= malloc(max_length);
bind_result[i].buffer_length= max_length;
}
}
if (mysql_stmt_bind_result(stmt, bind_result)){
g_err << "Failed to bind result: " << mysql_error(m_mysql) << endl;
mysql_stmt_close(stmt);
return false;
}
while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
{
Properties curr(true);
for (uint i= 0; i < num_fields; i++){
if (is_int_type(fields[i].type))
curr.put(fields[i].name, *(int*)bind_result[i].buffer);
else
curr.put(fields[i].name, (char*)bind_result[i].buffer);
}
rows.put("row", row++, &curr);
}
mysql_free_result(res);
for (uint i= 0; i < num_fields; i++)
free(bind_result[i].buffer);
}
// Save stats in result set
rows.put("rows", row);
rows.put("affected_rows", mysql_affected_rows(m_mysql));
rows.put("mysql_errno", mysql_errno(m_mysql));
rows.put("mysql_error", mysql_error(m_mysql));
rows.put("mysql_sqlstate", mysql_sqlstate(m_mysql));
rows.put("insert_id", mysql_insert_id(m_mysql));
mysql_stmt_close(stmt);
return true;
}
bool
DbUtil::runQuery(const char* sql,
const Properties& args,
SqlResultSet& rows){
clear_error();
rows.clear();
if (!isConnected())
return false;
assert(m_mysql);
g_debug << "runQuery: " << endl
<< " sql: '" << sql << "'" << endl;
MYSQL_STMT *stmt= mysql_stmt_init(m_mysql);
if (mysql_stmt_prepare(stmt, sql, (unsigned long)strlen(sql)))
{
report_error("Failed to prepare: ", m_mysql);
return false;
}
uint params= mysql_stmt_param_count(stmt);
MYSQL_BIND *bind_param = new MYSQL_BIND[params];
NdbAutoObjArrayPtr<MYSQL_BIND> _guard(bind_param);
memset(bind_param, 0, params * sizeof(MYSQL_BIND));
for(uint i= 0; i < mysql_stmt_param_count(stmt); i++)
{
BaseString name;
name.assfmt("%d", i);
// Parameters are named 0, 1, 2...
if (!args.contains(name.c_str()))
{
g_err << "param " << i << " missing" << endl;
assert(false);
}
PropertiesType t;
Uint32 val_i;
const char* val_s;
args.getTypeOf(name.c_str(), &t);
switch(t) {
case PropertiesType_Uint32:
args.get(name.c_str(), &val_i);
bind_param[i].buffer_type= MYSQL_TYPE_LONG;
bind_param[i].buffer= (char*)&val_i;
g_debug << " param" << name.c_str() << ": " << val_i << endl;
break;
case PropertiesType_char:
args.get(name.c_str(), &val_s);
bind_param[i].buffer_type= MYSQL_TYPE_STRING;
bind_param[i].buffer= (char*)val_s;
bind_param[i].buffer_length= (unsigned long)strlen(val_s);
g_debug << " param" << name.c_str() << ": " << val_s << endl;
break;
default:
assert(false);
break;
}
}
if (mysql_stmt_bind_param(stmt, bind_param))
{
report_error("Failed to bind param: ", m_mysql);
mysql_stmt_close(stmt);
return false;
}
if (mysql_stmt_execute(stmt))
{
report_error("Failed to execute: ", m_mysql);
mysql_stmt_close(stmt);
return false;
}
/*
Update max_length, making it possible to know how big
buffers to allocate
*/
my_bool one= 1;
mysql_stmt_attr_set(stmt, STMT_ATTR_UPDATE_MAX_LENGTH, (void*) &one);
if (mysql_stmt_store_result(stmt))
{
report_error("Failed to store result: ", m_mysql);
mysql_stmt_close(stmt);
return false;
}
uint row= 0;
MYSQL_RES* res= mysql_stmt_result_metadata(stmt);
if (res != NULL)
{
MYSQL_FIELD *fields= mysql_fetch_fields(res);
uint num_fields= mysql_num_fields(res);
MYSQL_BIND *bind_result = new MYSQL_BIND[num_fields];
NdbAutoObjArrayPtr<MYSQL_BIND> _guard1(bind_result);
memset(bind_result, 0, num_fields * sizeof(MYSQL_BIND));
for (uint i= 0; i < num_fields; i++)
{
unsigned long buf_len= sizeof(int);
switch(fields[i].type){
case MYSQL_TYPE_STRING:
buf_len = fields[i].length + 1;
break;
case MYSQL_TYPE_VARCHAR:
case MYSQL_TYPE_VAR_STRING:
buf_len= fields[i].max_length + 1;
break;
case MYSQL_TYPE_LONGLONG:
buf_len= sizeof(long long);
break;
case MYSQL_TYPE_LONG:
buf_len = sizeof(long);
break;
default:
break;
}
bind_result[i].buffer_type= fields[i].type;
bind_result[i].buffer= malloc(buf_len);
bind_result[i].buffer_length= buf_len;
bind_result[i].is_null = (my_bool*)malloc(sizeof(my_bool));
* bind_result[i].is_null = 0;
}
if (mysql_stmt_bind_result(stmt, bind_result)){
report_error("Failed to bind result: ", m_mysql);
mysql_stmt_close(stmt);
return false;
}
while (mysql_stmt_fetch(stmt) != MYSQL_NO_DATA)
{
Properties curr(true);
for (uint i= 0; i < num_fields; i++){
if (* bind_result[i].is_null)
continue;
switch(fields[i].type){
case MYSQL_TYPE_STRING:
((char*)bind_result[i].buffer)[fields[i].max_length] = 0;
case MYSQL_TYPE_VARCHAR:
case MYSQL_TYPE_VAR_STRING:
curr.put(fields[i].name, (char*)bind_result[i].buffer);
break;
case MYSQL_TYPE_LONGLONG:
curr.put64(fields[i].name,
*(unsigned long long*)bind_result[i].buffer);
break;
default:
curr.put(fields[i].name, *(int*)bind_result[i].buffer);
break;
}
}
rows.put("row", row++, &curr);
}
mysql_free_result(res);
for (uint i= 0; i < num_fields; i++)
{
free(bind_result[i].buffer);
free(bind_result[i].is_null);
}
}
// Save stats in result set
rows.put("rows", row);
rows.put64("affected_rows", mysql_affected_rows(m_mysql));
rows.put("mysql_errno", mysql_errno(m_mysql));
rows.put("mysql_error", mysql_error(m_mysql));
rows.put("mysql_sqlstate", mysql_sqlstate(m_mysql));
rows.put64("insert_id", mysql_insert_id(m_mysql));
mysql_stmt_close(stmt);
return true;
}
DatabaseException::DatabaseException(MYSQL *db, const std::string &initialMessage) {
_errno = mysql_errno(db);
_errorMessage = mysql_error(db);
_initialMessage = initialMessage;
_sqlState = mysql_sqlstate(db);
}
inline void MySqlConn::printError() {
printf("mysql error: %u (%s) %s\n", mysql_errno(m_mysql), mysql_sqlstate(m_mysql),
mysql_error(m_mysql));
}
void Connection::ShowMySQLError(st_mysql* mysql, char const* call)
{
fprintf(stderr, "%s: Error(%d) [%s] \"%s\"\n", call,
mysql_errno(mysql), mysql_sqlstate(mysql), mysql_error(mysql));
}
