int MysqlResultSet_next(T R) {
assert(R);
if (R->stop)
return false;
if (R->maxRows && (R->currentRow++ >= R->maxRows)) {
R->stop = true;
#if MYSQL_VERSION_ID >= 50002
/* Seems to need a cursor to work */
mysql_stmt_reset(R->stmt);
#else
/* Bhaa! Where's my cancel method?
Pencil neck mysql developers! */
while (mysql_stmt_fetch(R->stmt) == 0);
#endif
return false;
}
if (R->needRebind) {
if ((R->lastError = mysql_stmt_bind_result(R->stmt, R->bind)))
THROW(SQLException, "mysql_stmt_bind_result -- %s", mysql_stmt_error(R->stmt));
R->needRebind = false;
}
R->lastError = mysql_stmt_fetch(R->stmt);
if (R->lastError == 1)
THROW(SQLException, "mysql_stmt_fetch -- %s", mysql_stmt_error(R->stmt));
return ((R->lastError == MYSQL_OK) || (R->lastError == MYSQL_DATA_TRUNCATED));
}
static bool database_fetch(database_handler_t* handler)
{
if (mysql_stmt_fetch(handler->stmt))
{
if (mysql_stmt_errno(handler->stmt) == CR_SERVER_GONE_ERROR)
{
debug_log("try to reopen mysql\n");
if (!database_handler_reopen(handler))
{
error_log("reopen failure:%d,%s\n", mysql_stmt_errno(handler->stmt), mysql_stmt_error(handler->stmt));
return false;
}
debug_log("reopen success\n");
if (mysql_stmt_fetch(handler->stmt))
{
/*error_log("mysql_stmt_prepare error:%d,%s\n", mysql_stmt_errno(handler->stmt), mysql_stmt_error(handler->stmt));*/
return false;
}
return true;
}
/*error_log("mysql_stmt_fetch error:%s\n", mysql_stmt_error(handler->stmt));*/
return false;
}
return true;
}
gint
mysql_cursor_fetch (GSQLCursor *cursor, gint rows)
{
GSQL_TRACE_FUNC;
GSQLEMySQLCursor *e_cursor = NULL;
gchar error_str[2048];
gint ret = 1;
g_return_if_fail (GSQL_CURSOR (cursor) != NULL);
e_cursor = cursor->spec;
mysql_variable_clear (cursor);
if (ret = mysql_stmt_fetch (e_cursor->statement))
{
switch (ret)
{
case MYSQL_NO_DATA:
return 0;
case MYSQL_DATA_TRUNCATED:
gsql_message_add (gsql_session_get_workspace (cursor->session), GSQL_MESSAGE_WARNING,
N_("Data truncated. It is mean that internal error occured. Please, report this bug."));
return 0;
default:
g_sprintf (error_str, "Error occured: [%d]%s", ret, mysql_stmt_error (e_cursor->statement));
gsql_message_add (gsql_session_get_workspace (cursor->session), GSQL_MESSAGE_WARNING,
error_str);
return -1;
}
}
return 1;
}
Row Cursor::fetch()
{
log_debug("mysql_stmt_fetch(" << stmt << ')');
int ret = mysql_stmt_fetch(stmt);
if (ret == MYSQL_DATA_TRUNCATED)
{
// fetch column data where truncated
MYSQL_FIELD* fields = mysqlStatement->getFields();
for (unsigned n = 0; n < row->getSize(); ++n)
{
if (*row->getMysqlBind()[n].length > row->getMysqlBind()[n].buffer_length)
{
// actual length was longer than buffer_length, so this column is truncated
fields[n].length = *row->getMysqlBind()[n].length;
row->initOutBuffer(n, fields[n]);
log_debug("mysql_stmt_fetch_column(" << stmt << ", BIND, " << n
<< ", 0) with " << fields[n].length << " bytes");
if (mysql_stmt_fetch_column(stmt, row->getMysqlBind() + n, n, 0) != 0)
throw MysqlStmtError("mysql_stmt_fetch_column", stmt);
}
}
}
else if (ret == MYSQL_NO_DATA)
{
log_debug("MYSQL_NO_DATA");
row = 0;
return Row();
}
else if (ret == 1)
throw MysqlStmtError("mysql_stmt_fetch", stmt);
return Row(&*row);
}
/*==========================================
* ステートメント結果セットの次レコードを取得
*------------------------------------------
*/
bool sqldbs_stmt_fetch(struct sqldbs_stmt *st)
{
int ret = 0;
const char *msg = NULL;
nullpo_retr(false, st);
ret = mysql_stmt_fetch(st->stmt);
switch(ret) {
case 0:
return true;
case MYSQL_NO_DATA:
return false;
case MYSQL_DATA_TRUNCATED:
msg = "data truncated";
break;
default:
msg = mysql_stmt_error(st->stmt);
break;
}
if(msg) {
printf("DB server Error - %s\n %s\n\n", msg, st->query);
}
return false;
}
static int
table_mysql_check(int service, const char *key)
{
MYSQL_STMT *stmt;
int r, s;
stmt = table_mysql_query(key, service);
if (stmt == NULL)
return (-1);
r = -1;
s = mysql_stmt_fetch(stmt);
if (s == 0)
r = 1;
else if (s == MYSQL_NO_DATA)
r = 0;
else
log_warnx("warn: table-mysql: mysql_stmt_fetch: %s",
mysql_stmt_error(stmt));
if (mysql_stmt_free_result(stmt))
log_warnx("warn: table-mysql: mysql_stmt_free_result: %s",
mysql_stmt_error(stmt));
return (r);
}
static int perf1(MYSQL *mysql)
{
int rc;
MYSQL_STMT *stmt;
const char *stmtstr= "SELECT s.emp_no, s.salary, e.emp_no, e.first_name, e.last_name, e.gender FROM salaries s, employees e WHERE s.emp_no = e.emp_no";
rc= mysql_select_db(mysql, "employees");
if (rc)
{
diag("Employees database not installed");
return SKIP;
}
stmt= mysql_stmt_init(mysql);
diag("prepare");
rc= mysql_stmt_prepare(stmt, stmtstr, (unsigned long)strlen(stmtstr));
check_stmt_rc(rc, stmt);
diag("execute");
rc= mysql_stmt_execute(stmt);
check_stmt_rc(rc, stmt);
diag("store");
rc= mysql_stmt_store_result(stmt);
check_stmt_rc(rc, stmt);
diag("fetch");
while (!mysql_stmt_fetch(stmt));
mysql_stmt_close(stmt);
return OK;
}
/* bool fetch (); */
NS_IMETHODIMP jxMySQL50Statement::Fetch(PRBool *_retval)
{
if (mConnection == nsnull)
{
SET_ERROR_RETURN (JX_MYSQL50_ERROR_NOT_CONNECTED);
}
if (mSTMT == nsnull)
{
SET_ERROR_RETURN (JX_MYSQL50_ERROR_STMT_NULL);
}
PRInt32 ret = mysql_stmt_fetch(mSTMT);
*_retval = PR_FALSE;
if (!ret || ret == MYSQL_DATA_TRUNCATED) {
*_retval = PR_TRUE;
} else if (ret == MYSQL_NO_DATA) {
*_retval = PR_FALSE;
} else
{
// const char* err = mysql_stmt_error(mSTMT);
PRUint32 eno = mysql_stmt_errno(mSTMT);
if ( eno == 2050 || eno == 2051 || eno == 2052 || eno == 2053)
{
// No result set
return NS_OK;
}
SET_ERROR_RETURN (JX_MYSQL50_MYSQL_ERROR);
}
return NS_OK;
}
bool embeddedResult::fetchNext()
{
if(!d->driver)
return false;
if (d->preparedQuery) {
#if MYSQL_VERSION_ID >= 40108
int nRC = mysql_stmt_fetch(d->stmt);
if (nRC) {
#ifdef MYSQL_DATA_TRUNCATED
if (nRC == 1 || nRC == MYSQL_DATA_TRUNCATED)
#else
if (nRC == 1)
#endif // MYSQL_DATA_TRUNCATED
setLastError(qMakeStmtError(QCoreApplication::translate("embeddedResult",
"Unable to fetch data"), QSqlError::StatementError, d->stmt));
return false;
}
#else
return false;
#endif
} else {
d->row = mysql_fetch_row(d->result);
if (!d->row)
return false;
}
setAt(at() + 1);
return true;
}
IResultRow *MyBoundResults::FetchRow()
{
if (!MoreRows())
{
m_CurRow = m_RowCount + 1;
return NULL;
}
m_CurRow++;
if (m_bUpdatedBinds)
{
if (mysql_stmt_bind_result(m_stmt, m_bind) != 0)
{
return NULL;
}
m_bUpdatedBinds = false;
}
/* We should be able to get another row */
int err = mysql_stmt_fetch(m_stmt);
if (err == 0 || err == MYSQL_DATA_TRUNCATED)
{
return this;
}
if (err == MYSQL_NO_DATA && m_CurRow == m_RowCount)
{
return this;
}
/* Some sort of error occurred */
return NULL;
}
bool mysql_stmt_resultset::next()
{
if (stmt_ == NULL)
return false;
if (status_ == -1)
{
get_results();
if (status_ == -1)
return false;
}
int res = mysql_stmt_fetch(stmt_);
if (res == 1 || res == MYSQL_DATA_TRUNCATED)
throw database_exception(last_stmt_error(stmt_));
if (res == MYSQL_NO_DATA)
{
return false;
}
return true;
}
bool database::get_oauth_user(char *access_token, int *OAuthUserID, int *UserID,
int *expires_at) {
MYSQL_STMT *stmt;
MYSQL_BIND pbind[1];
memset(pbind, 0, sizeof(pbind));
bool result = false;
pbind[0].buffer_type = MYSQL_TYPE_STRING;
pbind[0].buffer = (char *)access_token;
pbind[0].buffer_length = strnlen(access_token, 512);
const char sql[] =
"SELECT t.user_id, c.parent_id, t.expires_at FROM "
"`supla_oauth_access_tokens` AS t, `supla_oauth_clients` AS c WHERE c.id "
"= t.client_id AND c.parent_id != 0 AND t.expires_at > "
"UNIX_TIMESTAMP(NOW()) AND t.scope = 'restapi' AND token = ? LIMIT 1";
if (stmt_execute((void **)&stmt, sql, pbind, 1, true)) {
mysql_stmt_store_result(stmt);
if (mysql_stmt_num_rows(stmt) > 0) {
MYSQL_BIND rbind[3];
memset(rbind, 0, sizeof(rbind));
int _OAuthUserID, _UserID, _expires_at;
rbind[0].buffer_type = MYSQL_TYPE_LONG;
rbind[0].buffer = (char *)&_OAuthUserID;
rbind[1].buffer_type = MYSQL_TYPE_LONG;
rbind[1].buffer = (char *)&_UserID;
rbind[2].buffer_type = MYSQL_TYPE_LONG;
rbind[2].buffer = (char *)&_expires_at;
if (mysql_stmt_bind_result(stmt, rbind)) {
supla_log(LOG_ERR, "MySQL - stmt bind error - %s",
mysql_stmt_error(stmt));
} else if (mysql_stmt_fetch(stmt) == 0) {
if (OAuthUserID != NULL) *OAuthUserID = _OAuthUserID;
if (UserID != NULL) *UserID = _UserID;
if (expires_at != NULL) {
*expires_at = _expires_at;
}
result = true;
}
}
mysql_stmt_free_result(stmt);
mysql_stmt_close(stmt);
}
return result;
}
bool bind_result_t::next_impl()
{
if (_handle->debug)
std::cerr << "MySQL debug: Accessing next row of handle at " << _handle.get() << std::endl;
auto flag = mysql_stmt_fetch(_handle->mysql_stmt);
switch (flag)
{
case 0:
case MYSQL_DATA_TRUNCATED:
{
bool need_to_rebind = false;
for (auto& r : _handle->result_param_meta_data)
{
if (r.len)
{
if (r.bound_is_null)
{
*r.text_buffer = nullptr;
*r.len = 0;
}
else
{
if (r.bound_len > r.bound_text_buffer.size())
{
if (_handle->debug)
std::cerr << "MySQL debug: Need to reallocate buffer at index " << r.index << " for handle at "
<< _handle.get() << std::endl;
need_to_rebind = true;
r.bound_text_buffer.resize(r.bound_len);
MYSQL_BIND& param = _handle->result_params[r.index];
param.buffer = r.bound_text_buffer.data();
param.buffer_length = r.bound_text_buffer.size();
if (mysql_stmt_fetch_column(_handle->mysql_stmt, _handle->result_params.data() + r.index, r.index, 0))
throw sqlpp::exception(std::string("MySQL: Fetch column after reallocate failed: ") +
mysql_stmt_error(_handle->mysql_stmt));
}
*r.text_buffer = r.bound_text_buffer.data();
*r.len = r.bound_len;
}
}
if (r.is_null)
*r.is_null = r.bound_is_null;
}
if (need_to_rebind)
bind_impl();
}
return true;
case 1:
throw sqlpp::exception(std::string("MySQL: Could not fetch next result: ") +
mysql_stmt_error(_handle->mysql_stmt));
case MYSQL_NO_DATA:
return false;
default:
throw sqlpp::exception("MySQL: Unexpected return value for mysql_stmt_fetch()");
}
}
int test_sp_reset1(MYSQL *mysql)
{
int rc;
MYSQL_STMT *stmt;
MYSQL_BIND bind[1];
char tmp[20];
char *stmtstr= "CALL P1(?)";
rc= mysql_query(mysql, "DROP PROCEDURE IF EXISTS p1");
check_mysql_rc(rc, mysql);
rc= mysql_query(mysql, "CREATE PROCEDURE p1(OUT p_out VARCHAR(19))"
"BEGIN "
" SET p_out = 'foo';"
" SELECT 'foo' FROM DUAL;"
" SELECT 'bar' FROM DUAL;"
"END");
check_mysql_rc(rc, mysql);
stmt= mysql_stmt_init(mysql);
check_mysql_rc(rc, mysql);
rc= mysql_stmt_prepare(stmt, stmtstr, strlen(stmtstr));
check_stmt_rc(rc, stmt);
memset(tmp, 0, sizeof(tmp));
memset(bind, 0, sizeof(MYSQL_BIND));
bind[0].buffer= tmp;
bind[0].buffer_type= MYSQL_TYPE_STRING;
bind[0].buffer_length= 4;
mysql_stmt_bind_param(stmt, bind);
rc= mysql_stmt_execute(stmt);
check_stmt_rc(rc, stmt);
rc= mysql_stmt_store_result(stmt);
check_stmt_rc(rc, stmt);
rc= mysql_stmt_next_result(stmt);
check_stmt_rc(rc, stmt);
rc= mysql_stmt_fetch(stmt);
check_stmt_rc(rc, stmt);
/* mysql_stmt_reset should set statement in prepared state.
* this means: all subsequent result sets should be flushed.
* Let's try!
*/
rc= mysql_stmt_reset(stmt);
check_stmt_rc(rc, stmt);
rc= mysql_query(mysql, "DROP PROCEDURE p1");
check_mysql_rc(rc, mysql);
mysql_stmt_close(stmt);
return OK;
}
bool selectStmt()
{
std::unique_ptr<MYSQL, MysqlDestroy> mysql{mysql_init(nullptr)};
if (mysql_options(&*mysql, MYSQL_SET_CHARSET_NAME, "utf8") != 0) {
printf("error mysql_options\n");
return false;
}
if (!mysql_real_connect(&*mysql, IP.c_str(), USER.c_str(), PASSWORD.c_str(), "mytest", PORT,nullptr,0)) {
printf("error mysql_real_connect\n");
return false;
}
const std::string sql = "select fid, fname, fsid from test where fid = 1";
std::unique_ptr<MYSQL_STMT, MysqlStmtDestroy> mysql_stmt{mysql_stmt_init(&*mysql)};
mysql_stmt_prepare(&*mysql_stmt, sql.data(), sql.size());
if (mysql_stmt_execute(&*mysql_stmt) != 0) {
printf("error mysql_stmt_execute\n");
return false;
}
mysql_stmt_store_result(&*mysql_stmt);
std::array<MYSQL_BIND,3> bind{};
std::array<std::array<char, 50>, 3> bind_buffer{};
std::array<unsigned long, 3> bind_length{};
std::memset(bind.data(), 0, sizeof(bind));
bind[0].buffer = bind_buffer[0].data();
bind[0].buffer_length = 50;
bind[0].length = &bind_length[0];
bind[1].buffer = bind_buffer[1].data();
bind[1].buffer_length = 50;
bind[1].length = &bind_length[1];
bind[2].buffer = bind_buffer[2].data();
bind[2].buffer_length = 50;
bind[2].length = &bind_length[2];
if (mysql_stmt_bind_result(&*mysql_stmt, bind.data())) {
printf("mysql_stmt_bind_result error\n");
return false;
}
while (mysql_stmt_fetch(&*mysql_stmt) == 0) {
int fid = 0;
std::memcpy(&fid, bind[0].buffer, *bind[0].length);
char* p = (char*)bind[1].buffer;
for (unsigned long i = 0; i != *bind[1].length; ++i) {
printf("%c ", p[i]);
}
printf("\n");
}
return true;
}
bool PreparedResultSet::_NextRow()
{
/// Only called in low-level code, namely the constructor
/// Will iterate over every row of data and buffer it
if (m_rowPosition >= m_rowCount)
return false;
int retval = mysql_stmt_fetch(m_stmt);
return retval == 0 || retval == MYSQL_DATA_TRUNCATED;
}
static int dbd_mysql_get_row(apr_pool_t *pool, apr_dbd_results_t *res,
apr_dbd_row_t **row, int rownum)
{
MYSQL_ROW r = NULL;
int ret = 0;
if (res->statement) {
if (res->random) {
if (rownum > 0) {
mysql_stmt_data_seek(res->statement, (my_ulonglong) --rownum);
}
else {
return -1; /* invalid row */
}
}
ret = mysql_stmt_fetch(res->statement);
switch (ret) {
case 1:
ret = mysql_stmt_errno(res->statement);
break;
case MYSQL_NO_DATA:
ret = -1;
break;
default:
ret = 0; /* bad luck - get_entry will deal with this */
break;
}
}
else {
if (res->random) {
if (rownum > 0) {
mysql_data_seek(res->res, (my_ulonglong) --rownum);
}
else {
return -1; /* invalid row */
}
}
r = mysql_fetch_row(res->res);
if (r == NULL) {
ret = -1;
}
}
if (ret == 0) {
if (!*row) {
*row = apr_palloc(pool, sizeof(apr_dbd_row_t));
}
(*row)->row = r;
(*row)->res = res;
(*row)->len = mysql_fetch_lengths(res->res);
}
else {
apr_pool_cleanup_run(res->pool, res->res, free_result);
}
return ret;
}
static int test_bug11111(MYSQL *mysql)
{
MYSQL_STMT *stmt;
MYSQL_BIND my_bind[2];
char buf[2][20];
ulong len[2];
int i;
int rc;
const char *query= "SELECT DISTINCT f1,ff2 FROM v1";
rc= mysql_query(mysql, "drop table if exists t1, t2, v1");
check_mysql_rc(rc, mysql);
rc= mysql_query(mysql, "drop view if exists t1, t2, v1");
check_mysql_rc(rc, mysql);
rc= mysql_query(mysql, "create table t1 (f1 int, f2 int)");
check_mysql_rc(rc, mysql);
rc= mysql_query(mysql, "create table t2 (ff1 int, ff2 int)");
check_mysql_rc(rc, mysql);
rc= mysql_query(mysql, "create view v1 as select * from t1, t2 where f1=ff1");
check_mysql_rc(rc, mysql);
rc= mysql_query(mysql, "insert into t1 values (1,1), (2,2), (3,3)");
check_mysql_rc(rc, mysql);
rc= mysql_query(mysql, "insert into t2 values (1,1), (2,2), (3,3)");
check_mysql_rc(rc, mysql);
stmt= mysql_stmt_init(mysql);
rc= mysql_stmt_prepare(stmt, query, strlen(query));
check_stmt_rc(rc, stmt);
rc= mysql_stmt_execute(stmt);
check_stmt_rc(rc, stmt);
memset(my_bind, '\0', sizeof(my_bind));
for (i=0; i < 2; i++)
{
my_bind[i].buffer_type= MYSQL_TYPE_STRING;
my_bind[i].buffer= (uchar* *)&buf[i];
my_bind[i].buffer_length= 20;
my_bind[i].length= &len[i];
}
rc= mysql_stmt_bind_result(stmt, my_bind);
check_stmt_rc(rc, stmt);
rc= mysql_stmt_fetch(stmt);
check_stmt_rc(rc, stmt);
FAIL_UNLESS(!strcmp(buf[1],"1"), "buf[1] != '1'");
mysql_stmt_close(stmt);
rc= mysql_query(mysql, "drop view v1");
check_mysql_rc(rc, mysql);
rc= mysql_query(mysql, "drop table t1, t2");
check_mysql_rc(rc, mysql);
return OK;
}
int test_sp_reset(MYSQL *mysql)
{
int i, rc;
MYSQL_STMT *stmt;
int a[] = {10,20,30};
MYSQL_BIND bind[3];
char *stmtstr= "CALL P1(?,?,?)";
rc= mysql_query(mysql, "DROP PROCEDURE IF EXISTS p1");
check_mysql_rc(rc, mysql);
rc= mysql_query(mysql, "CREATE PROCEDURE p1(OUT p_out VARCHAR(19), IN p_in INT, INOUT p_inout INT)"
"BEGIN "
" SET p_in = 300, p_out := 'This is OUT param', p_inout = 200; "
" SELECT p_inout, p_in, substring(p_out, 9);"
"END");
check_mysql_rc(rc, mysql);
stmt= mysql_stmt_init(mysql);
check_mysql_rc(rc, mysql);
rc= mysql_stmt_prepare(stmt, stmtstr, strlen(stmtstr));
check_stmt_rc(rc, stmt);
FAIL_IF(mysql_stmt_param_count(stmt) != 3, "expected param_count=3");
memset(bind, 0, sizeof(MYSQL_BIND) * 3);
for (i=0; i < 3; i++)
{
bind[i].buffer= &a[i];
bind[i].buffer_type= MYSQL_TYPE_LONG;
}
bind[0].buffer_type= MYSQL_TYPE_NULL;
rc= mysql_stmt_bind_param(stmt, bind);
check_stmt_rc(rc, stmt);
rc= mysql_stmt_execute(stmt);
check_stmt_rc(rc, stmt);
rc= mysql_stmt_fetch(stmt);
check_stmt_rc(rc, stmt);
rc= mysql_stmt_reset(stmt);
check_stmt_rc(rc, stmt);
/*connection shouldn't be blocked now */
rc= mysql_query(mysql, "DROP PROCEDURE p1");
check_mysql_rc(rc, mysql);
rc= mysql_stmt_close(stmt);
return OK;
}
bool next()
{
if (!stmt)
return false;
int rc = mysql_stmt_fetch(*stmt);
if (rc == MYSQL_NO_DATA)
return false;
else if (rc)
fail(mysql_stmt_error(*stmt));
else
return true;
}
static int test_view_star(MYSQL *mysql)
{
MYSQL_STMT *stmt;
int rc, i;
MYSQL_BIND my_bind[8];
char parms[8][100];
ulong length[8];
const char *query= "SELECT * FROM vt1 WHERE a IN (?,?)";
rc= mysql_query(mysql, "DROP TABLE IF EXISTS t1, vt1");
check_mysql_rc(rc, mysql);
rc= mysql_query(mysql, "DROP VIEW IF EXISTS t1, vt1");
check_mysql_rc(rc, mysql);
rc= mysql_query(mysql, "CREATE TABLE t1 (a int)");
check_mysql_rc(rc, mysql);
rc= mysql_query(mysql, "CREATE VIEW vt1 AS SELECT a FROM t1");
check_mysql_rc(rc, mysql);
memset(my_bind, '\0', sizeof(MYSQL_BIND));
for (i= 0; i < 2; i++) {
sprintf((char *)&parms[i], "%d", i);
my_bind[i].buffer_type = MYSQL_TYPE_VAR_STRING;
my_bind[i].buffer = (char *)&parms[i];
my_bind[i].buffer_length = 100;
my_bind[i].is_null = 0;
my_bind[i].length = &length[i];
length[i] = 1;
}
stmt= mysql_stmt_init(mysql);
rc= mysql_stmt_prepare(stmt, query, strlen(query));
check_stmt_rc(rc, stmt);
rc= mysql_stmt_bind_param(stmt, my_bind);
check_stmt_rc(rc, stmt);
for (i= 0; i < 3; i++)
{
rc= mysql_stmt_execute(stmt);
check_stmt_rc(rc, stmt);
rc= mysql_stmt_fetch(stmt);
FAIL_UNLESS(MYSQL_NO_DATA == rc, "Expected 0 rows");
}
mysql_stmt_close(stmt);
rc= mysql_query(mysql, "DROP TABLE t1");
check_mysql_rc(rc, mysql);
rc= mysql_query(mysql, "DROP VIEW vt1");
check_mysql_rc(rc, mysql);
return OK;
}
int CMySQLDynamicRecordSet::FetchRow()
{
if(m_hStmt)
{
int Ret=mysql_stmt_fetch(m_hStmt);
if(Ret)
{
if(Ret==MYSQL_DATA_TRUNCATED)
{
m_pDBConnection->ProcessErrorMsg(m_hStmt,"出现数据截断");
return DBERR_FETCH_RESULT_FAIL;
}
else if(Ret==MYSQL_NO_DATA)
{
m_IsEOF=true;
return DBERR_NO_RECORDS;
}
else
{
m_pDBConnection->ProcessErrorMsg(m_hStmt,"获取结果集失败");
return DBERR_FETCH_RESULT_FAIL;
}
}
int ColNum=GetColumnCount();
for(int i=0;i<ColNum;i++)
{
if(*(m_FetchBuffer[i].is_null))
{
m_RowBuffer[i].SetNULLValue(m_pColumnInfos[i].Type);
}
else
{
if(!CMySQLConnection::MySQLBinValueToDBValue(m_FetchBuffer[i].buffer_type,
m_FetchBuffer[i].buffer,*(m_FetchBuffer[i].length),
m_pColumnInfos[i].Type,m_pColumnInfos[i].DigitSize,
m_RowBuffer[i]))
{
return DBERR_BINDPARAMFAIL;
}
}
}
m_IsBOF=false;
m_IsEOF=false;
return DBERR_SUCCEED;
}
else
{
return DBERR_NO_RECORDS;
}
}
std::vector<int> DBManager::check_jobs() {
std::vector<int> job_ids;
char *stmt_str = "SELECT id FROM wkdd_ldp_jobs WHERE status = 'pending' ORDER BY start_time ASC";
MYSQL_BIND result[1];
int my_job_id;
if (mysql_stmt_prepare(m_stmt, stmt_str, strlen(stmt_str)) != 0) {
print_stmt_error("could not prepare select statement");
return job_ids;
}
if (mysql_stmt_field_count(m_stmt) != 1) {
print_stmt_error("unexpected column count from select");
return job_ids;
}
// initialize result column structures
memset((void *)result, 0, sizeof(result)); // zero the structures
// set up my_id parameter
result[0].buffer_type = MYSQL_TYPE_LONG;
result[0].buffer = (void *) &my_job_id;
result[0].is_unsigned = 0;
result[0].is_null = 0;
if (mysql_stmt_bind_result(m_stmt, result) != 0) {
print_stmt_error("could not bind parameters for select");
return job_ids;
}
if (mysql_stmt_execute(m_stmt) != 0) {
print_stmt_error("could not execute select");
return job_ids;
}
// fetch result set into client memory; this is optional, but it allows mysql_stmt_num_rows() to be called to determine the number of rows in the result set
if (mysql_stmt_store_result(m_stmt) != 0) {
print_stmt_error("could not buffer result set");
return job_ids;
}
while (mysql_stmt_fetch(m_stmt) == 0) { // fetch each row
// store into vector
job_ids.push_back(my_job_id);
}
// deallocate result set
mysql_stmt_free_result(m_stmt);
return job_ids;
}
bool StatementExecutor::fetch()
{
if (_state < STMT_EXECUTED)
throw StatementException("Statement is not executed yet");
int res = mysql_stmt_fetch(_pHandle);
// we have specified zero buffers for BLOBs, so DATA_TRUNCATED is normal in this case
if ((res != 0) && (res != MYSQL_NO_DATA) && (res != MYSQL_DATA_TRUNCATED))
throw StatementException("mysql_stmt_fetch error", _pHandle, _query);
return (res == 0) || (res == MYSQL_DATA_TRUNCATED);
}
void database::get_client_locations(int ClientID,
supla_client_locations *locs) {
MYSQL_STMT *stmt;
const char sql[] =
"SELECT `id`, `caption` FROM `supla_v_client_location` WHERE "
"`client_id` = ?";
MYSQL_BIND pbind[1];
memset(pbind, 0, sizeof(pbind));
pbind[0].buffer_type = MYSQL_TYPE_LONG;
pbind[0].buffer = (char *)&ClientID;
if (stmt_execute((void **)&stmt, sql, pbind, 1, true)) {
my_bool is_null[2];
MYSQL_BIND rbind[2];
memset(rbind, 0, sizeof(rbind));
int id;
unsigned long size;
char caption[401]; // utf8
rbind[0].buffer_type = MYSQL_TYPE_LONG;
rbind[0].buffer = (char *)&id;
rbind[0].is_null = &is_null[0];
rbind[1].buffer_type = MYSQL_TYPE_STRING;
rbind[1].buffer = caption;
rbind[1].buffer_length = 401;
rbind[1].length = &size;
rbind[1].is_null = &is_null[1];
if (mysql_stmt_bind_result(stmt, rbind)) {
supla_log(LOG_ERR, "MySQL - stmt bind error - %s",
mysql_stmt_error(stmt));
} else {
mysql_stmt_store_result(stmt);
if (mysql_stmt_num_rows(stmt) > 0) {
while (!mysql_stmt_fetch(stmt)) {
caption[size] = 0;
locs->add_location(id, caption);
}
}
}
mysql_stmt_close(stmt);
}
}
static bool db_stmt_step_mysql(const struct db_stmt *stmt, struct db_row *row)
{
struct db_stmt_mysql *stmt_mysql = (struct db_stmt_mysql *)stmt;
if (stmt_mysql->must_execute_again) {
stmt_mysql->must_execute_again = false;
if (mysql_stmt_execute(stmt_mysql->stmt))
return false;
}
if (!stmt_mysql->result_bind) {
size_t n_rows = 0;
for (struct db_row *r = row; r->kind != '\0'; r++)
n_rows++;
if (!n_rows)
return false;
stmt_mysql->result_bind = calloc(n_rows, sizeof(*stmt_mysql->result_bind));
if (!stmt_mysql->result_bind)
return false;
stmt_mysql->param_bind = calloc(n_rows, sizeof(*stmt_mysql->param_bind));
if (!stmt_mysql->param_bind) {
free(stmt_mysql->result_bind);
return false;
}
MYSQL_BIND *result = stmt_mysql->result_bind;
for (size_t r = 0; r < n_rows; r++) {
if (row[r].kind == 's') {
result[r].buffer_type = MYSQL_TYPE_STRING;
result[r].buffer = row[r].u.s;
} else if (row[r].kind == 'i') {
result[r].buffer_type = MYSQL_TYPE_LONG;
result[r].buffer = &row[r].u.i;
} else {
return false;
}
result[r].is_null = false;
result[r].buffer_length = row[r].buffer_length;
}
if (mysql_stmt_bind_result(stmt_mysql->stmt, result))
return false;
}
return mysql_stmt_fetch(stmt_mysql->stmt) == 0;
}
int db_read_fetch() {
_fetch = mysql_stmt_fetch(_mysql_stmt);
switch(_fetch) {
case 1:
mysql_stmt_close(_mysql_stmt);
finish_with_error(LOG_ERR, "Failed to fetch prepared MySQL statement result");
return -1;
break;
case MYSQL_NO_DATA:
return 0;
default:
return 1;
}
}
int my_cmd_next(db_res_t* res)
{
int ret;
struct my_cmd* mcmd;
mcmd = DB_GET_PAYLOAD(res->cmd);
if (mcmd->next_flag == 2 || mcmd->next_flag == -2) return 1;
if (mcmd->st == NULL) {
ERR("mysql: Prepared statement not found\n");
return -1;
}
ret = mysql_stmt_fetch(mcmd->st);
if (ret == MYSQL_NO_DATA) {
mcmd->next_flag = mcmd->next_flag<0?-2:2;
return 1;
}
/* MYSQL_DATA_TRUNCATED is only defined in mysql >= 5.0 */
#if defined MYSQL_DATA_TRUNCATED
if (ret == MYSQL_DATA_TRUNCATED) {
int i;
ERR("mysql: mysql_stmt_fetch, data truncated, fields: %d\n", res->cmd->result_count);
for (i = 0; i < res->cmd->result_count; i++) {
if (mcmd->st->bind[i].error /*&& mcmd->st->bind[i].buffer_length*/) {
ERR("mysql: truncation, bind %d, length: %lu, buffer_length: %lu\n",
i, *(mcmd->st->bind[i].length), mcmd->st->bind[i].buffer_length);
}
}
ret = 0;
}
#endif
if (mcmd->next_flag <= 0) {
mcmd->next_flag++;
}
if (ret != 0) {
ERR("mysql: Error in mysql_stmt_fetch (ret=%d): %s\n", ret, mysql_stmt_error(mcmd->st));
return -1;
}
if (update_result(res->cmd->result, mcmd->st) < 0) {
mysql_stmt_free_result(mcmd->st);
return -1;
}
res->cur_rec->fld = res->cmd->result;
return 0;
}
bool MmsServer::CheckWhiteList(unsigned int uid, YYLibMysql * mysql)
{
// mysql process
if (!mysql || !mysql->_sql)
return false;
YYLibMysql::StmtItem item(mysql->_sql);
// mysql->Execute("DROP TABLE test1");
// item.Prepare("CREATE TABLE IF NOT EXISTS test1(idx int AUTO_INCREMENT, id int, label varchar(250), v1 TINYINT, v2 SMALLINT, v3 BIGINT, v4 FLOAT, v5 DOUBLE, PRIMARY KEY(idx) );") << Execute();
// item.Prepare("INSERT INTO test1(id, label, v1, v2, v3, v4, v5) VALUES (?,?,?,?,?,?,?)") << 10 << buf->buf() << (signed char)3 << (short int)5 << (long long)100 << (float)4.5 << (double)55.5 << Execute();
// item << 20 << buf->buf() << (signed char)10 << (short int)500 << (long long)100000 << (float)4.455 << (double)55.534543 << Execute();
char sz[40]; sprintf(sz, "%u", uid);
std::string sql = "SELECT * FROM mms_whitelist WHERE mms_whitelist_uid="; sql += sz;
item.Prepare(sql.c_str()) << Execute();
std::auto_ptr<YYLibMysql::StmtRes> res(item.GetRes());
if (res->BindResult())
{
int column_count = mysql_num_fields(res->_res);
int row = 0;
while (!mysql_stmt_fetch(res->_stmt))
{
long value;
char * buf;
row++;
for (int i = 0; i < column_count; i++)
{
switch(res->_bind[i].buffer_type)
{
case MYSQL_TYPE_LONG:
{
value = *(long*)res->_bind[i].buffer;
}
break;
case MYSQL_TYPE_STRING:
case MYSQL_TYPE_VARCHAR:
case MYSQL_TYPE_VAR_STRING:
{
buf = (char*)res->_bind[i].buffer;
}
break;
}
}
}
}
return true;
}
/**
* Convert rows from mysql to db API representation
*/
static inline int db_mysql_convert_rows(const db_con_t* _h, db_res_t* _r)
{
int row;
if ((!_h) || (!_r)) {
LM_ERR("invalid parameter\n");
return -1;
}
if (CON_HAS_PS(_h)) {
RES_ROW_N(_r) = mysql_stmt_num_rows(CON_PS_STMT(_h));
} else {
RES_ROW_N(_r) = mysql_num_rows(CON_RESULT(_h));
}
if (!RES_ROW_N(_r)) {
LM_DBG("no rows returned from the query\n");
RES_ROWS(_r) = 0;
return 0;
}
if (db_allocate_rows( _r, RES_ROW_N(_r))!=0) {
LM_ERR("no private memory left\n");
return -2;
}
for(row = 0; row < RES_ROW_N(_r); row++) {
if (CON_HAS_PS(_h)) {
mysql_stmt_fetch(CON_PS_STMT(_h));
//if(mysql_stmt_fetch(CON_PS_STMT(_h))!=1)
// LM_ERR("STMT ERR=%s\n",mysql_stmt_error(CON_PS_STMT(_h)));
} else {
CON_ROW(_h) = mysql_fetch_row(CON_RESULT(_h));
if (!CON_ROW(_h)) {
LM_ERR("driver error: %s\n", mysql_error(CON_CONNECTION(_h)));
RES_ROW_N(_r) = row;
db_free_rows(_r);
return -3;
}
}
if (db_mysql_convert_row(_h, _r, &(RES_ROWS(_r)[row])) < 0) {
LM_ERR("error while converting row #%d\n", row);
RES_ROW_N(_r) = row;
db_free_rows(_r);
return -4;
}
}
return 0;
}