static bool database_free_result(database_handler_t* handler)
{
if (mysql_stmt_free_result(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_free_result(handler->stmt))
{
error_log("mysql_stmt_free_result error:%d,%s\n", mysql_stmt_errno(handler->stmt), mysql_stmt_error(handler->stmt));
return false;
}
return true;
}
error_log("mysql_stmt_free_result error:%d,%s\n", mysql_stmt_errno(handler->stmt), mysql_stmt_error(handler->stmt));
return false;
}
return true;
}
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 void
on_cursor_close (GSQLCursor *cursor, gpointer user_data)
{
GSQL_TRACE_FUNC;
GSQLEMySQLCursor *e_cursor;
GSQLEMySQLVariable *var;
gint i;
g_return_if_fail (GSQL_IS_CURSOR(cursor));
if (cursor->spec != NULL)
{
e_cursor = (GSQLEMySQLCursor *)cursor->spec;
if (e_cursor->statement)
{
mysql_stmt_free_result(e_cursor->statement);
mysql_stmt_close(e_cursor->statement);
}
g_free (e_cursor->binds);
g_free (e_cursor);
}
}
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;
}
Statement::~Statement() {
if (_resultWasStored) {
mysql_stmt_free_result(_stmt);
}
mysql_stmt_close(_stmt);
ClearParameters();
ClearResults();
}
axStatus axDBConn_MySQL::beginTran () {
if( lastExecStmt_ ) {
mysql_stmt_free_result( lastExecStmt_ );
}
lastExecStmt_ = NULL;
return _directExec( "START TRANSACTION;");
}
void PreparedResultSet::CleanUp() {
/// More of the in our code allocated sources are deallocated by the poorly documented mysql c api
if (m_res)
mysql_free_result(m_res);
FreeBindBuffer();
mysql_stmt_free_result(m_stmt);
delete[] m_rBind;
}
void Statement::ResetParameters() {
while (! _params.empty()) {
ParamBuffer *buf = _params.back();
_params.pop_back();
delete buf;
}
mysql_stmt_reset(_stmt);
mysql_stmt_free_result(_stmt);
_eof = true;
}
void PreparedResultSet::cleanUp()
{
/// More of the in our code allocated sources are deallocated by the poorly documented mysql c api
if (m_res)
mysql_free_result(m_res);
freeBindBuffer();
mysql_stmt_free_result(m_stmt);
MM_CHECKOUT(m_rBind);
}
void mysql_statement::clear()
{
for (int i = 0; i < host_size; ++i) {
if (host_array[i].buffer) {
delete [] static_cast<char*>(host_array[i].buffer);
}
}
result_size = 0;
host_size = 0;
mysql_stmt_free_result(stmt);
delete [] host_array;
}
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;
}
void MysqlResultSet_free(T *R) {
assert(R && *R);
for (int i = 0; i < (*R)->columnCount; i++)
FREE((*R)->columns[i].buffer);
mysql_stmt_free_result((*R)->stmt);
if ((*R)->keep == false)
mysql_stmt_close((*R)->stmt);
if ((*R)->meta)
mysql_free_result((*R)->meta);
FREE((*R)->columns);
FREE((*R)->bind);
FREE(*R);
}
void MysqlPreparedStatement_free(T *P) {
assert(P && *P);
FREE((*P)->bind);
mysql_stmt_free_result((*P)->stmt);
#if MYSQL_VERSION_ID >= 50503
/* In case the statement returns multiple result sets or in a stored procedure case,
think it does, we need to run them down. mysql_stmt_reset does not seem to work here. */
while (mysql_stmt_next_result((*P)->stmt) == 0);
#endif
mysql_stmt_close((*P)->stmt);
FREE((*P)->params);
FREE(*P);
}
int sqlite3_finalize(mysqlite3_stmt* pStmt)
{
if (pStmt)
{
if (pStmt->sql)
{
free(pStmt->sql);
}
if (pStmt->mystmt)
{
mysql_stmt_free_result(pStmt->mystmt);
mysql_stmt_close(pStmt->mystmt);
}
int i;
for (i=0; i < pStmt->nparams; i++)
{
// Need to clean up buffers
if (pStmt->myparams[i].buffer)
{
free(pStmt->myparams[i].buffer);
}
if (pStmt->results && pStmt->results[i].buffer)
{
free(pStmt->results[i].buffer);
}
}
if (pStmt->lengths) {
free(pStmt->lengths);
}
if (pStmt->results) {
free(pStmt->results);
}
if (pStmt->myparams)
{
free(pStmt->myparams);
}
mysql_free_result(pStmt->myres);
free(pStmt);
}
return 0;
};
void my_res_free(db_res_t* res, struct my_res* payload)
{
struct my_cmd* mcmd;
mcmd = DB_GET_PAYLOAD(res->cmd);
if (mcmd->st && mysql_stmt_free_result(mcmd->st)) {
ERR("mysql: Error while freeing MySQL result: %d, %s\n",
mysql_stmt_errno(mcmd->st), mysql_stmt_error(mcmd->st));
}
db_drv_free(&payload->gen);
pkg_free(payload);
}
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;
}
static void gt_rdb_stmt_mysql_delete(GtRDBStmt *st)
{
GtRDBStmtMySQL *stm;
if (!st) return;
stm = gt_rdb_stmt_mysql_cast(st);
if (stm->stmt) {
mysql_stmt_free_result(stm->stmt);
mysql_stmt_close(stm->stmt);
}
gt_free(stm->params);
gt_free(stm->results);
gt_hashtable_delete(stm->buffers);
gt_hashtable_delete(stm->returned_strings);
gt_str_delete(stm->query);
}
SqlPreparedStatement::~SqlPreparedStatement()
{
if (mResultMetadata != nullptr)
{
mysql_free_result(mResultMetadata);
mResultMetadata = nullptr;
}
mResultFields.Clear();
if (mSTMT != nullptr)
{
mysql_stmt_free_result(mSTMT);
mysql_stmt_close(mSTMT);
mSTMT = nullptr;
}
}
json::Node PreparedQueryBase::_fetchResults( void ){
// If we don't have any result binders, just return null.
if( m_resultsSize == 0 ){
return json::Node( JSON_NULL );
}
// We have results to fetch, so lets fetch them!
json::Node results( JSON_ARRAY );
int res = 0;
while( (res = mysql_stmt_fetch( m_statement )), !res || res == MYSQL_DATA_TRUNCATED ){
results.push_back( _resultRowToJSONArray() );
}
// Free up the results in the MySQL library now.
mysql_stmt_free_result( m_statement );
return results;
}
void freeResultset(struct driverMySQL_preparedresultset* rs)
{
if (rs == NULL)
return;
freeMetaInfo(rs->metaInfo,rs->returnFields);
freeBind(rs->bindResult,rs->returnFields);
if ( rs->statement != NULL )
{
mysql_stmt_free_result(rs->statement);
mysql_stmt_close(rs->statement);
}
free(rs);
rs = NULL;
return;
}
/* this may be called manually or during GC */
static void rb_mysql_result_free_result(mysql2_result_wrapper * wrapper) {
if (!wrapper) return;
if (wrapper->resultFreed != 1) {
if (wrapper->stmt_wrapper) {
if (!wrapper->stmt_wrapper->closed) {
mysql_stmt_free_result(wrapper->stmt_wrapper->stmt);
/* MySQL BUG? If the statement handle was previously used, and so
* mysql_stmt_bind_result was called, and if that result set and bind buffers were freed,
* MySQL still thinks the result set buffer is available and will prefetch the
* first result in mysql_stmt_execute. This will corrupt or crash the program.
* By setting bind_result_done back to 0, we make MySQL think that a result set
* has never been bound to this statement handle before to prevent the prefetch.
*/
wrapper->stmt_wrapper->stmt->bind_result_done = 0;
}
if (wrapper->statement != Qnil) {
decr_mysql2_stmt(wrapper->stmt_wrapper);
}
if (wrapper->result_buffers) {
unsigned int i;
for (i = 0; i < wrapper->numberOfFields; i++) {
if (wrapper->result_buffers[i].buffer) {
xfree(wrapper->result_buffers[i].buffer);
}
}
xfree(wrapper->result_buffers);
xfree(wrapper->is_null);
xfree(wrapper->error);
xfree(wrapper->length);
}
/* Clue that the next statement execute will need to allocate a new result buffer. */
wrapper->result_buffers = NULL;
}
/* FIXME: this may call flush_use_result, which can hit the socket */
/* For prepared statements, wrapper->result is the result metadata */
mysql_free_result(wrapper->result);
wrapper->resultFreed = 1;
}
}
int mysql_drv_free_results(db_result_set_t *rs)
{
#ifdef HAVE_PS
/* Is this a result set of a prepared statement */
if (rs->statement != NULL && rs->statement->emulated == 0)
{
DEBUG("mysql_stmt_free_result(%p)", rs->statement->ptr);
return mysql_stmt_free_result(rs->statement->ptr);
}
#endif
if (rs->ptr != NULL)
{
DEBUG("mysql_free_result(%p)", rs->ptr);
mysql_free_result((MYSQL_RES *)rs->ptr);
return 0;
}
return 1;
}
static int gt_rdb_stmt_mysql_reset(GtRDBStmt *st, GtError *err)
{
GtRDBStmtMySQL *stm;
int rval, had_err = 0;
gt_assert(st);
gt_error_check(err);
stm = gt_rdb_stmt_mysql_cast(st);
gt_hashtable_reset(stm->buffers);
gt_hashtable_reset(stm->returned_strings);
mysql_stmt_free_result(stm->stmt);
if ((rval = mysql_stmt_reset(stm->stmt))) {
gt_error_set(err, GT_MYSQL_ERRMSG, rval, mysql_stmt_error(stm->stmt));
had_err = -1;
}
memset(stm->params, 0, stm->num_params*sizeof (MYSQL_BIND));
gt_free(stm->results);
stm->results = NULL;
if (!had_err)
stm->executed = false;
return had_err;
}
/*
* Selects inode from database with given inode and gen number.
*
* Return: 0 on success, -1 on error
* Return: inode information copied into result
*/
int
sam_db_inode_select(
sam_db_context_t *con,
sam_id_t id,
sam_db_inode_t *result)
{
int err;
MYSQL_STMT *stmt;
MYSQL_BIND bind[2];
MYSQL_BIND bind_result[10];
memset(bind, 0, sizeof (bind));
memset(bind_result, 0, sizeof (bind_result));
SAMDB_BIND(bind[0], id.ino, MYSQL_TYPE_LONG, TRUE);
SAMDB_BIND(bind[1], id.gen, MYSQL_TYPE_LONG, TRUE);
bind_inode(bind_result, result, TRUE);
if ((stmt = sam_db_execute_sql(con, bind,
bind_result, INO_SELECT)) == NULL) {
Trace(TR_ERR, "Error selecting inode %d.%d", id.ino, id.gen);
return (-1);
}
if ((err = mysql_stmt_fetch(stmt)) != 0) {
if (err == MYSQL_NO_DATA) {
return (MYSQL_NO_DATA);
}
Trace(TR_ERR, "Error fetching inode %d.%d: %s", id.ino, id.gen,
mysql_error(con->mysql));
return (-1);
}
if (mysql_stmt_free_result(stmt) != 0) {
Trace(TR_ERR, "Error freeing result: %s",
mysql_error(con->mysql));
}
return (0);
}
bool SqlPreparedStatement::Prepare()
{
auto sql = Sql();
mSTMT = mysql_stmt_init(Sql());
if (mSTMT == nullptr)
{
throw SqlException(sql, "Error in SqlPreparedStatement::mysql_stmt_init");
}
if (mysql_stmt_prepare(mSTMT, mStatement.c_str(), (ulong)mStatement.Length()) != 0)
{
SqlException e(mSTMT, "Error in SqlPreparedStatement::mysql_stmt_prepare");
mysql_stmt_free_result(mSTMT);
mysql_stmt_close(mSTMT);
throw e;
}
mParamterCount = mysql_stmt_param_count(mSTMT);
mResultCount = mysql_stmt_field_count(mSTMT);
if (mResultCount!=0)
{
if ((mResultMetadata = mysql_stmt_result_metadata(mSTMT)) == NULL)
{
throw SqlException(mSTMT, "Error in SqlPreparedStatement::mysql_stmt_result_metadata");
}
MYSQL_FIELD* field = nullptr;
while ((field = mysql_fetch_field(mResultMetadata)) != nullptr)
{
mResultFields.Add(field);
}
}
return true;
}
DBJob DBManager::get_job(const int& id) {
DBJob data;
char *stmt_str = "SELECT term, type FROM wkdd_ldp_jobs WHERE id = ?";
MYSQL_BIND param[1];
MYSQL_BIND result[2];
int my_job_id;
int my_type;
char my_term[2000];
unsigned long my_term_length;
if (mysql_stmt_prepare(m_stmt, stmt_str, strlen(stmt_str)) != 0) {
print_stmt_error("could not prepare select statement");
return data;
}
if (mysql_stmt_field_count(m_stmt) != 2) {
print_stmt_error("unexpected column count from select");
return data;
}
// initialize result column structures
memset((void *)param, 0, sizeof(param));
memset((void *)result, 0, sizeof(result)); // zero the structures
// set up my_id parameter
param[0].buffer_type = MYSQL_TYPE_LONG;
param[0].buffer = (void *) &my_job_id;
param[0].is_unsigned = 0;
param[0].is_null = 0;
// set up my_term parameter
result[0].buffer_type = MYSQL_TYPE_STRING;
result[0].buffer = (void *) &my_term;
result[0].buffer_length = sizeof(my_term);
result[0].length = &my_term_length;
result[0].is_null = 0;
// set up my_type parameter
result[1].buffer_type = MYSQL_TYPE_LONG;
result[1].buffer = (void *) &my_type;
result[1].is_unsigned = 0;
result[1].is_null = 0;
if (mysql_stmt_bind_param(m_stmt, param) != 0) {
print_stmt_error("could not bind parameters for select");
return data;
}
if (mysql_stmt_bind_result(m_stmt, result) != 0) {
print_stmt_error("could not bind parameters for select");
return data;
}
// set variable
my_job_id = id;
if (mysql_stmt_execute(m_stmt) != 0) {
print_stmt_error("could not execute select");
return data;
}
// 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 data;
}
mysql_stmt_fetch(m_stmt); // fetch the single result
data = DBJob(my_term, my_type);
// deallocate result set
mysql_stmt_free_result(m_stmt);
return data;
}
/*
* the new order transaction
*/
int neword( int t_num,
int w_id_arg, /* warehouse id */
int d_id_arg, /* district id */
int c_id_arg, /* customer id */
int o_ol_cnt_arg, /* number of items */
int o_all_local_arg, /* are all order lines local */
int itemid[], /* ids of items to be ordered */
int supware[], /* warehouses supplying items */
int qty[] /* quantity of each item */
)
{
int w_id = w_id_arg;
int d_id = d_id_arg;
int c_id = c_id_arg;
int o_ol_cnt = o_ol_cnt_arg;
int o_all_local = o_all_local_arg;
float c_discount;
char c_last[17];
char c_credit[3];
float w_tax;
int d_next_o_id;
float d_tax;
char datetime[81];
int o_id;
char i_name[25];
float i_price;
char i_data[51];
int ol_i_id;
int s_quantity;
char s_data[51];
char s_dist_01[25];
char s_dist_02[25];
char s_dist_03[25];
char s_dist_04[25];
char s_dist_05[25];
char s_dist_06[25];
char s_dist_07[25];
char s_dist_08[25];
char s_dist_09[25];
char s_dist_10[25];
char ol_dist_info[25];
int ol_supply_w_id;
float ol_amount;
int ol_number;
int ol_quantity;
char iname[MAX_NUM_ITEMS][MAX_ITEM_LEN];
char bg[MAX_NUM_ITEMS];
float amt[MAX_NUM_ITEMS];
float price[MAX_NUM_ITEMS];
int stock[MAX_NUM_ITEMS];
float total = 0.0;
int min_num;
int i,j,tmp,swp;
int ol_num_seq[MAX_NUM_ITEMS];
int proceed = 0;
MYSQL_STMT* mysql_stmt;
MYSQL_BIND param[9];
MYSQL_BIND column[12];
/* EXEC SQL WHENEVER NOT FOUND GOTO sqlerr;*/
/* EXEC SQL WHENEVER SQLERROR GOTO sqlerr;*/
/*EXEC SQL CONTEXT USE :ctx[t_num];*/
gettimestamp(datetime, STRFTIME_FORMAT, TIMESTAMP_LEN);
proceed = 1;
/*EXEC_SQL SELECT c_discount, c_last, c_credit, w_tax
INTO :c_discount, :c_last, :c_credit, :w_tax
FROM customer, warehouse
WHERE w_id = :w_id
AND c_w_id = w_id
AND c_d_id = :d_id
AND c_id = :c_id;*/
mysql_stmt = stmt[t_num][0];
memset(param, 0, sizeof(MYSQL_BIND) * 3); /* initialize */
param[0].buffer_type = MYSQL_TYPE_LONG;
param[0].buffer = &w_id;
param[1].buffer_type = MYSQL_TYPE_LONG;
param[1].buffer = &d_id;
param[2].buffer_type = MYSQL_TYPE_LONG;
param[2].buffer = &c_id;
if( mysql_stmt_bind_param(mysql_stmt, param) ) goto sqlerr;
if( mysql_stmt_execute(mysql_stmt) ) goto sqlerr;
if( mysql_stmt_store_result(mysql_stmt) ) goto sqlerr;
memset(column, 0, sizeof(MYSQL_BIND) * 4); /* initialize */
column[0].buffer_type = MYSQL_TYPE_FLOAT;
column[0].buffer = &c_discount;
column[1].buffer_type = MYSQL_TYPE_STRING;
column[1].buffer = c_last;
column[1].buffer_length = sizeof(c_last);
column[2].buffer_type = MYSQL_TYPE_STRING;
column[2].buffer = c_credit;
column[2].buffer_length = sizeof(c_credit);
column[3].buffer_type = MYSQL_TYPE_FLOAT;
column[3].buffer = &w_tax;
if( mysql_stmt_bind_result(mysql_stmt, column) ) goto sqlerr;
switch( mysql_stmt_fetch(mysql_stmt) ) {
case 0: //SUCCESS
case MYSQL_DATA_TRUNCATED:
break;
case 1: //ERROR
case MYSQL_NO_DATA: //NO MORE DATA
default:
mysql_stmt_free_result(mysql_stmt);
goto sqlerr;
}
mysql_stmt_free_result(mysql_stmt);
#ifdef DEBUG
printf("n %d\n",proceed);
#endif
proceed = 2;
/*EXEC_SQL SELECT d_next_o_id, d_tax INTO :d_next_o_id, :d_tax
FROM district
WHERE d_id = :d_id
AND d_w_id = :w_id
FOR UPDATE;*/
mysql_stmt = stmt[t_num][1];
memset(param, 0, sizeof(MYSQL_BIND) * 2); /* initialize */
param[0].buffer_type = MYSQL_TYPE_LONG;
param[0].buffer = &d_id;
param[1].buffer_type = MYSQL_TYPE_LONG;
param[1].buffer = &w_id;
if( mysql_stmt_bind_param(mysql_stmt, param) ) goto sqlerr;
if( mysql_stmt_execute(mysql_stmt) ) goto sqlerr;
if( mysql_stmt_store_result(mysql_stmt) ) goto sqlerr;
memset(column, 0, sizeof(MYSQL_BIND) * 2); /* initialize */
column[0].buffer_type = MYSQL_TYPE_LONG;
column[0].buffer = &d_next_o_id;
column[1].buffer_type = MYSQL_TYPE_FLOAT;
column[1].buffer = &d_tax;
if( mysql_stmt_bind_result(mysql_stmt, column) ) goto sqlerr;
switch( mysql_stmt_fetch(mysql_stmt) ) {
case 0: //SUCCESS
case MYSQL_DATA_TRUNCATED:
break;
case 1: //ERROR
case MYSQL_NO_DATA: //NO MORE DATA
default:
mysql_stmt_free_result(mysql_stmt);
goto sqlerr;
}
mysql_stmt_free_result(mysql_stmt);
proceed = 3;
/*EXEC_SQL UPDATE district SET d_next_o_id = :d_next_o_id + 1
WHERE d_id = :d_id
AND d_w_id = :w_id;*/
mysql_stmt = stmt[t_num][2];
memset(param, 0, sizeof(MYSQL_BIND) * 3); /* initialize */
param[0].buffer_type = MYSQL_TYPE_LONG;
param[0].buffer = &d_next_o_id;
param[1].buffer_type = MYSQL_TYPE_LONG;
param[1].buffer = &d_id;
param[2].buffer_type = MYSQL_TYPE_LONG;
param[2].buffer = &w_id;
if( mysql_stmt_bind_param(mysql_stmt, param) ) goto sqlerr;
if( mysql_stmt_execute(mysql_stmt) ) goto sqlerr;
o_id = d_next_o_id;
#ifdef DEBUG
printf("n %d\n",proceed);
#endif
proceed = 4;
/*EXEC_SQL INSERT INTO orders (o_id, o_d_id, o_w_id, o_c_id,
o_entry_d, o_ol_cnt, o_all_local)
VALUES(:o_id, :d_id, :w_id, :c_id,
:datetime,
:o_ol_cnt, :o_all_local);*/
mysql_stmt = stmt[t_num][3];
memset(param, 0, sizeof(MYSQL_BIND) * 7); /* initialize */
param[0].buffer_type = MYSQL_TYPE_LONG;
param[0].buffer = &o_id;
param[1].buffer_type = MYSQL_TYPE_LONG;
param[1].buffer = &d_id;
param[2].buffer_type = MYSQL_TYPE_LONG;
param[2].buffer = &w_id;
param[3].buffer_type = MYSQL_TYPE_LONG;
param[3].buffer = &c_id;
param[4].buffer_type = MYSQL_TYPE_STRING;
param[4].buffer = datetime;
param[4].buffer_length = strlen(datetime);
param[5].buffer_type = MYSQL_TYPE_LONG;
param[5].buffer = &o_ol_cnt;
param[6].buffer_type = MYSQL_TYPE_LONG;
param[6].buffer = &o_all_local;
if( mysql_stmt_bind_param(mysql_stmt, param) ) goto sqlerr;
if( mysql_stmt_execute(mysql_stmt) ) goto sqlerr;
#ifdef DEBUG
printf("n %d\n",proceed);
#endif
proceed = 5;
/* EXEC_SQL INSERT INTO new_orders (no_o_id, no_d_id, no_w_id)
VALUES (:o_id,:d_id,:w_id); */
mysql_stmt = stmt[t_num][4];
memset(param, 0, sizeof(MYSQL_BIND) * 3); /* initialize */
param[0].buffer_type = MYSQL_TYPE_LONG;
param[0].buffer = &o_id;
param[1].buffer_type = MYSQL_TYPE_LONG;
param[1].buffer = &d_id;
param[2].buffer_type = MYSQL_TYPE_LONG;
param[2].buffer = &w_id;
if( mysql_stmt_bind_param(mysql_stmt, param) ) goto sqlerr;
if( mysql_stmt_execute(mysql_stmt) ) goto sqlerr;
/* sort orders to avoid DeadLock */
for (i = 0; i < o_ol_cnt; i++) {
ol_num_seq[i]=i;
}
for (i = 0; i < (o_ol_cnt - 1); i++) {
tmp = (MAXITEMS + 1) * supware[ol_num_seq[i]] + itemid[ol_num_seq[i]];
min_num = i;
for ( j = i+1; j < o_ol_cnt; j++) {
if ( (MAXITEMS + 1) * supware[ol_num_seq[j]] + itemid[ol_num_seq[j]] < tmp ){
tmp = (MAXITEMS + 1) * supware[ol_num_seq[j]] + itemid[ol_num_seq[j]];
min_num = j;
}
}
if ( min_num != i ){
swp = ol_num_seq[min_num];
ol_num_seq[min_num] = ol_num_seq[i];
ol_num_seq[i] = swp;
}
}
for (ol_number = 1; ol_number <= o_ol_cnt; ol_number++) {
ol_supply_w_id = supware[ol_num_seq[ol_number - 1]];
ol_i_id = itemid[ol_num_seq[ol_number - 1]];
ol_quantity = qty[ol_num_seq[ol_number - 1]];
/* EXEC SQL WHENEVER NOT FOUND GOTO invaliditem; */
proceed = 6;
/*EXEC_SQL SELECT i_price, i_name, i_data
INTO :i_price, :i_name, :i_data
FROM item
WHERE i_id = :ol_i_id;*/
mysql_stmt = stmt[t_num][5];
memset(param, 0, sizeof(MYSQL_BIND) * 1); /* initialize */
param[0].buffer_type = MYSQL_TYPE_LONG;
param[0].buffer = &ol_i_id;
if( mysql_stmt_bind_param(mysql_stmt, param) ) goto sqlerr;
if( mysql_stmt_execute(mysql_stmt) ) goto sqlerr;
if( mysql_stmt_store_result(mysql_stmt) ) goto sqlerr;
memset(column, 0, sizeof(MYSQL_BIND) * 3); /* initialize */
column[0].buffer_type = MYSQL_TYPE_FLOAT;
column[0].buffer = &i_price;
column[1].buffer_type = MYSQL_TYPE_STRING;
column[1].buffer = i_name;
column[1].buffer_length = sizeof(i_name);
column[2].buffer_type = MYSQL_TYPE_STRING;
column[2].buffer = i_data;
column[2].buffer_length = sizeof(i_data);
if( mysql_stmt_bind_result(mysql_stmt, column) ) goto sqlerr;
switch( mysql_stmt_fetch(mysql_stmt) ) {
case 0: //SUCCESS
case MYSQL_DATA_TRUNCATED:
break;
case MYSQL_NO_DATA: //NO MORE DATA
mysql_stmt_free_result(mysql_stmt);
goto invaliditem;
case 1: //ERROR
default:
mysql_stmt_free_result(mysql_stmt);
goto sqlerr;
}
mysql_stmt_free_result(mysql_stmt);
price[ol_num_seq[ol_number - 1]] = i_price;
strncpy(iname[ol_num_seq[ol_number - 1]], i_name, 25);
/* EXEC SQL WHENEVER NOT FOUND GOTO sqlerr; */
#ifdef DEBUG
printf("n %d\n",proceed);
#endif
proceed = 7;
/*EXEC_SQL SELECT s_quantity, s_data, s_dist_01, s_dist_02,
s_dist_03, s_dist_04, s_dist_05, s_dist_06,
s_dist_07, s_dist_08, s_dist_09, s_dist_10
INTO :s_quantity, :s_data, :s_dist_01, :s_dist_02,
:s_dist_03, :s_dist_04, :s_dist_05, :s_dist_06,
:s_dist_07, :s_dist_08, :s_dist_09, :s_dist_10
FROM stock
WHERE s_i_id = :ol_i_id
AND s_w_id = :ol_supply_w_id
FOR UPDATE;*/
mysql_stmt = stmt[t_num][6];
memset(param, 0, sizeof(MYSQL_BIND) * 2); /* initialize */
param[0].buffer_type = MYSQL_TYPE_LONG;
param[0].buffer = &ol_i_id;
param[1].buffer_type = MYSQL_TYPE_LONG;
param[1].buffer = &ol_supply_w_id;
if( mysql_stmt_bind_param(mysql_stmt, param) ) goto sqlerr;
if( mysql_stmt_execute(mysql_stmt) ) goto sqlerr;
if( mysql_stmt_store_result(mysql_stmt) ) goto sqlerr;
memset(column, 0, sizeof(MYSQL_BIND) * 12); /* initialize */
column[0].buffer_type = MYSQL_TYPE_LONG;
column[0].buffer = &s_quantity;
column[1].buffer_type = MYSQL_TYPE_STRING;
column[1].buffer = s_data;
column[1].buffer_length = sizeof(s_data);
column[2].buffer_type = MYSQL_TYPE_STRING;
column[2].buffer = s_dist_01;
column[2].buffer_length = sizeof(s_dist_01);
column[3].buffer_type = MYSQL_TYPE_STRING;
column[3].buffer = s_dist_02;
column[3].buffer_length = sizeof(s_dist_02);
column[4].buffer_type = MYSQL_TYPE_STRING;
column[4].buffer = s_dist_03;
column[4].buffer_length = sizeof(s_dist_03);
column[5].buffer_type = MYSQL_TYPE_STRING;
column[5].buffer = s_dist_04;
column[5].buffer_length = sizeof(s_dist_04);
column[6].buffer_type = MYSQL_TYPE_STRING;
column[6].buffer = s_dist_05;
column[6].buffer_length = sizeof(s_dist_05);
column[7].buffer_type = MYSQL_TYPE_STRING;
column[7].buffer = s_dist_06;
column[7].buffer_length = sizeof(s_dist_06);
column[8].buffer_type = MYSQL_TYPE_STRING;
column[8].buffer = s_dist_07;
column[8].buffer_length = sizeof(s_dist_07);
column[9].buffer_type = MYSQL_TYPE_STRING;
column[9].buffer = s_dist_08;
column[9].buffer_length = sizeof(s_dist_08);
column[10].buffer_type = MYSQL_TYPE_STRING;
column[10].buffer = s_dist_09;
column[10].buffer_length = sizeof(s_dist_09);
column[11].buffer_type = MYSQL_TYPE_STRING;
column[11].buffer = s_dist_10;
column[11].buffer_length = sizeof(s_dist_10);
if( mysql_stmt_bind_result(mysql_stmt, column) ) goto sqlerr;
switch( mysql_stmt_fetch(mysql_stmt) ) {
case 0: //SUCCESS
break;
case 1: //ERROR
case MYSQL_NO_DATA: //NO MORE DATA
default:
mysql_stmt_free_result(mysql_stmt);
goto sqlerr;
}
mysql_stmt_free_result(mysql_stmt);
pick_dist_info(ol_dist_info, d_id); /* pick correct
* s_dist_xx */
stock[ol_num_seq[ol_number - 1]] = s_quantity;
if ((strstr(i_data, "original") != NULL) &&
(strstr(s_data, "original") != NULL))
bg[ol_num_seq[ol_number - 1]] = 'B';
else
bg[ol_num_seq[ol_number - 1]] = 'G';
if (s_quantity > ol_quantity)
s_quantity = s_quantity - ol_quantity;
else
s_quantity = s_quantity - ol_quantity + 91;
#ifdef DEBUG
printf("n %d\n",proceed);
#endif
proceed = 8;
/*EXEC_SQL UPDATE stock SET s_quantity = :s_quantity
WHERE s_i_id = :ol_i_id
AND s_w_id = :ol_supply_w_id;*/
mysql_stmt = stmt[t_num][7];
memset(param, 0, sizeof(MYSQL_BIND) * 3); /* initialize */
param[0].buffer_type = MYSQL_TYPE_LONG;
param[0].buffer = &s_quantity;
param[1].buffer_type = MYSQL_TYPE_LONG;
param[1].buffer = &ol_i_id;
param[2].buffer_type = MYSQL_TYPE_LONG;
param[2].buffer = &ol_supply_w_id;
if( mysql_stmt_bind_param(mysql_stmt, param) ) goto sqlerr;
if( mysql_stmt_execute(mysql_stmt) ) goto sqlerr;
ol_amount = ol_quantity * i_price * (1 + w_tax + d_tax) * (1 - c_discount);
amt[ol_num_seq[ol_number - 1]] = ol_amount;
total += ol_amount;
#ifdef DEBUG
printf("n %d\n",proceed);
#endif
proceed = 9;
/*EXEC_SQL INSERT INTO order_line (ol_o_id, ol_d_id, ol_w_id,
ol_number, ol_i_id,
ol_supply_w_id, ol_quantity,
ol_amount, ol_dist_info)
VALUES (:o_id, :d_id, :w_id, :ol_number, :ol_i_id,
:ol_supply_w_id, :ol_quantity, :ol_amount,
:ol_dist_info);*/
mysql_stmt = stmt[t_num][8];
memset(param, 0, sizeof(MYSQL_BIND) * 9); /* initialize */
param[0].buffer_type = MYSQL_TYPE_LONG;
param[0].buffer = &o_id;
param[1].buffer_type = MYSQL_TYPE_LONG;
param[1].buffer = &d_id;
param[2].buffer_type = MYSQL_TYPE_LONG;
param[2].buffer = &w_id;
param[3].buffer_type = MYSQL_TYPE_LONG;
param[3].buffer = &ol_number;
param[4].buffer_type = MYSQL_TYPE_LONG;
param[4].buffer = &ol_i_id;
param[5].buffer_type = MYSQL_TYPE_LONG;
param[5].buffer = &ol_supply_w_id;
param[6].buffer_type = MYSQL_TYPE_LONG;
param[6].buffer = &ol_quantity;
param[7].buffer_type = MYSQL_TYPE_FLOAT;
param[7].buffer = &ol_amount;
param[8].buffer_type = MYSQL_TYPE_STRING;
param[8].buffer = ol_dist_info;
param[8].buffer_length = strlen(ol_dist_info);
if( mysql_stmt_bind_param(mysql_stmt, param) ) goto sqlerr;
if( mysql_stmt_execute(mysql_stmt) ) goto sqlerr;
} /* End Order Lines */
#ifdef DEBUG
printf("insert 3\n");
fflush(stdout);
#endif
/*EXEC_SQL COMMIT WORK;*/
if( mysql_commit(ctx[t_num]) ) goto sqlerr;
return (1);
invaliditem:
/*EXEC_SQL ROLLBACK WORK;*/
mysql_rollback(ctx[t_num]);
/* printf("Item number is not valid\n"); */
return (1); /* OK? */
sqlerr:
fprintf(stderr,"neword %d:%d\n",t_num,proceed);
error(ctx[t_num],mysql_stmt);
/*EXEC SQL WHENEVER SQLERROR GOTO sqlerrerr;*/
/*EXEC_SQL ROLLBACK WORK;*/
mysql_rollback(ctx[t_num]);
sqlerrerr:
return (0);
}
static int
table_mysql_fetch(int service, char *dst, size_t sz)
{
MYSQL_STMT *stmt;
const char *k;
int s;
retry:
if (service != K_SOURCE)
return (-1);
stmt = config->stmt_fetch_source;
if (stmt == NULL)
return (-1);
if (config->source_ncall < config->source_refresh &&
time(NULL) - config->source_update < config->source_expire)
goto fetch;
if (mysql_stmt_execute(stmt)) {
if (mysql_stmt_errno(stmt) == CR_SERVER_LOST ||
mysql_stmt_errno(stmt) == CR_SERVER_GONE_ERROR ||
mysql_stmt_errno(stmt) == CR_COMMANDS_OUT_OF_SYNC) {
log_warnx("warn: table-mysql: trying to reconnect after error: %s",
mysql_stmt_error(stmt));
if (config_connect(config))
goto retry;
return (-1);
}
log_warnx("warn: table-mysql: mysql_stmt_execute: %s",
mysql_stmt_error(stmt));
return (-1);
}
config->source_iter = NULL;
while(dict_poproot(&config->sources, NULL, NULL))
;
while ((s = mysql_stmt_fetch(stmt)) == 0)
dict_set(&config->sources, results_buffer[0], NULL);
if (s && s != MYSQL_NO_DATA)
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));
config->source_update = time(NULL);
config->source_ncall = 0;
fetch:
config->source_ncall += 1;
if (! dict_iter(&config->sources, &config->source_iter, &k, (void **)NULL)) {
config->source_iter = NULL;
if (! dict_iter(&config->sources, &config->source_iter, &k, (void **)NULL))
return (0);
}
if (strlcpy(dst, k, sz) >= sz)
return (-1);
return (1);
}
static int
table_mysql_lookup(int service, const char *key, char *dst, size_t sz)
{
MYSQL_STMT *stmt;
int r, s;
stmt = table_mysql_query(key, service);
if (stmt == NULL)
return (-1);
s = mysql_stmt_fetch(stmt);
if (s == MYSQL_NO_DATA) {
r = 0;
goto end;
}
if (s != 0) {
r = -1;
log_warnx("warn: table-mysql: mysql_stmt_fetch: %s",
mysql_stmt_error(stmt));
goto end;
}
r = 1;
switch(service) {
case K_ALIAS:
do {
if (dst[0] && strlcat(dst, ", ", sz) >= sz) {
log_warnx("warn: table-mysql: result too large");
r = -1;
break;
}
if (strlcat(dst, results_buffer[0], sz) >= sz) {
log_warnx("warn: table-mysql: result too large");
r = -1;
break;
}
s = mysql_stmt_fetch(stmt);
} while (s == 0);
if (s && s != MYSQL_NO_DATA) {
log_warnx("warn: table-mysql: mysql_stmt_fetch: %s",
mysql_stmt_error(stmt));
r = -1;
}
break;
case K_CREDENTIALS:
if (snprintf(dst, sz, "%s:%s",
results_buffer[0],
results_buffer[1]) > (ssize_t)sz) {
log_warnx("warn: table-mysql: result too large");
r = -1;
}
break;
case K_USERINFO:
if (snprintf(dst, sz, "%s:%s:%s:%s",
results_buffer[0],
results_buffer[1],
results_buffer[2],
results_buffer[3]) > (ssize_t)sz) {
log_warnx("warn: table-mysql: result too large");
r = -1;
}
break;
case K_DOMAIN:
case K_NETADDR:
case K_SOURCE:
case K_MAILADDR:
case K_ADDRNAME:
if (strlcpy(dst, results_buffer[0], sz) >= sz) {
log_warnx("warn: table-mysql: result too large");
r = -1;
}
break;
default:
log_warnx("warn: table-mysql: unknown service %i",
service);
r = -1;
}
end:
if (mysql_stmt_free_result(stmt))
log_warnx("warn: table-mysql: mysql_stmt_free_result: %s",
mysql_stmt_error(stmt));
return (r);
}
int test_query(MYSQL *mysql)
{
int rc;
int i;
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 1 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);
for (i=0; i < 1000; i++)
{
int status;
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);
do {
if (stmt->field_count)
{
mysql_stmt_bind_result(stmt, bind);
rc= mysql_stmt_store_result(stmt);
check_stmt_rc(rc, stmt);
while(mysql_stmt_fetch(stmt) == 0);
rc= mysql_stmt_free_result(stmt);
check_stmt_rc(rc, stmt);
}
status= mysql_stmt_next_result(stmt);
if (status == 1)
check_stmt_rc(status, stmt);
} while (status == 0);
rc= mysql_stmt_reset(stmt);
if (rc)
diag("reset failed after %d iterations", i);
check_stmt_rc(rc, stmt);
}
mysql_stmt_close(stmt);
return OK;
}
