unsigned int GetMultiStatements(MADB_Stmt *Stmt, BOOL ExecDirect)
{
int i= 0;
unsigned int MaxParams= 0;
char *p= Stmt->Query.RefinedText;
Stmt->MultiStmtNr= 0;
Stmt->MultiStmts= (MYSQL_STMT **)MADB_CALLOC(sizeof(MYSQL_STMT) * STMT_COUNT(Stmt->Query));
while (p < Stmt->Query.RefinedText + Stmt->Query.RefinedLength)
{
Stmt->MultiStmts[i]= i == 0 ? Stmt->stmt : MADB_NewStmtHandle(Stmt);
MDBUG_C_PRINT(Stmt->Connection, "-->inited&preparing %0x(%d,%s)", Stmt->MultiStmts[i], i, p);
if (mysql_stmt_prepare(Stmt->MultiStmts[i], p, (unsigned long)strlen(p)))
{
MADB_SetNativeError(&Stmt->Error, SQL_HANDLE_STMT, Stmt->MultiStmts[i]);
CloseMultiStatements(Stmt);
/* Last paranoid attempt make sure that we did not have a parsing error.
More to preserve "backward-compatimility" - we did this before, but before trying to
prepare "multi-statement". */
if (i == 0 && Stmt->Error.NativeError !=1295 /*ER_UNSUPPORTED_PS*/)
{
Stmt->stmt= MADB_NewStmtHandle(Stmt);
if (mysql_stmt_prepare(Stmt->stmt, STMT_STRING(Stmt), (unsigned long)strlen(STMT_STRING(Stmt))))
{
mysql_stmt_close(Stmt->stmt);
Stmt->stmt= NULL;
}
else
{
MADB_DeleteSubqueries(&Stmt->Query);
return 0;
}
}
return 1;
}
if (mysql_stmt_param_count(Stmt->MultiStmts[i]) > MaxParams)
{
MaxParams= mysql_stmt_param_count(Stmt->MultiStmts[i]);
}
p+= strlen(p) + 1;
++i;
}
if (MaxParams)
{
Stmt->params= (MYSQL_BIND *)MADB_CALLOC(sizeof(MYSQL_BIND) * MaxParams);
}
return 0;
}
int MYSQLC::PrepareSQL(PGLOBAL g, const char *stmt)
{
if (!m_DB) {
strcpy(g->Message, "MySQL not connected");
return -4;
} else if (m_Stmt)
return -1; // should not append
#if defined(ALPHA)
if (!(m_Stmt = mysql_prepare(m_DB, stmt, strlen(stmt)))) {
sprintf(g->Message, "mysql_prepare failed: %s [%s]",
mysql_error(m_DB), stmt);
return -1;
} // endif m_Stmt
// Return the parameter count from the statement
return mysql_param_count(m_Stmt);
#else // !ALPHA
if (!(m_Stmt = mysql_stmt_init(m_DB))) {
strcpy(g->Message, "mysql_stmt_init(), out of memory");
return -2;
} // endif m_Stmt
if (mysql_stmt_prepare(m_Stmt, stmt, strlen(stmt))) {
sprintf(g->Message, "mysql_stmt_prepare() failed: (%d) %s",
mysql_stmt_errno(m_Stmt), mysql_stmt_error(m_Stmt));
return -3;
} // endif prepare
// Return the parameter count from the statement
return mysql_stmt_param_count(m_Stmt);
#endif // !ALPHA
} // end of PrepareSQL
/// Returns the number of parameters in the prepared statement.
size_t SqlStmt_NumParams(SqlStmt* self)
{
if( self )
return (size_t)mysql_stmt_param_count(self->stmt);
else
return 0;
}
void ObPSTest::delete_test()
{
MYSQL_STMT *stmt = mysql_stmt_init(&my_);
ASSERT_TRUE(stmt);
const char* QUERY = "delete from ob_ps_test where c1 = ?";
// 1. prepare
int ret = mysql_stmt_prepare(stmt, QUERY, strlen(QUERY));
ASSERT_QUERY_RET(ret);
int param_count = (int)mysql_stmt_param_count(stmt);
ASSERT_EQ(1, param_count);
// 2. bind params
MYSQL_BIND bind[1];
memset(bind, 0, sizeof(bind));
int int_data = 0;
bind[0].buffer_type= MYSQL_TYPE_LONG;
bind[0].buffer= (char *)&int_data;
bind[0].is_null= 0;
bind[0].length= 0;
ret = mysql_stmt_bind_param(stmt, bind);
ASSERT_QUERY_RET(ret);
// 3. execute
int_data = 3;
ret = mysql_stmt_execute(stmt);
ASSERT_QUERY_RET(ret);
// 4. results
my_ulonglong affected_rows = mysql_stmt_affected_rows(stmt);
ASSERT_EQ(1U, affected_rows);
// 5. clean up
ret = mysql_stmt_close(stmt);
ASSERT_QUERY_RET(ret);
}
statement::statement(st_mysql* mysql, const std::string& query)
{
stmt = mysql_stmt_init(mysql);
try
{
if (!stmt)
{
throw exception(__FILE__, __LINE__, "stmt_init failed");
}
if (mysql_stmt_prepare(stmt, query.c_str(), query.size()) != 0)
{
throw exception(__FILE__, __LINE__, mysql_stmt_error(stmt));
}
param_count = mysql_stmt_param_count(stmt);
binds.resize(0);
binds.resize(param_count, st_mysql_bind());
lengths.resize(0);
lengths.resize(param_count, 0);
bind_index = 0;
}
catch (...)
{
mysql_stmt_close(stmt);
throw;
}
}
int
lmt_db_insert_router_data (lmt_db_t db, char *rtrname, uint64_t bytes,
float pct_cpu)
{
MYSQL_BIND param[4];
uint64_t router_id;
int retval = -1;
assert (db->magic == LMT_DBHANDLE_MAGIC);
if (!db->ins_router_data) {
if (lmt_conf_get_db_debug ())
msg ("no permission to insert into %s ROUTER_DATA",
lmt_db_fsname (db));
goto done;
}
if (_lookup_idhash (db, "router", rtrname, &router_id) < 0) {
if (lmt_conf_get_db_autoconf ()) {
if (lmt_conf_get_db_debug ())
msg ("adding %s to %s ROUTER_INFO", rtrname,lmt_db_fsname (db));
if (_insert_router_info (db, rtrname, &router_id) < 0)
goto done;
} else {
if (lmt_conf_get_db_debug ())
msg ("%s: no entry in %s ROUTER_INFO and db_autoconf disabled",
rtrname, lmt_db_fsname (db));
retval = 0; /* avoid a reconnect */
goto done;
}
}
if (_update_timestamp (db) < 0)
goto done;
memset (param, 0, sizeof (param));
assert (mysql_stmt_param_count (db->ins_router_data) == 4);
_param_init_int (¶m[0], MYSQL_TYPE_LONG, &router_id);
_param_init_int (¶m[1], MYSQL_TYPE_LONG, &db->timestamp_id);
_param_init_int (¶m[2], MYSQL_TYPE_LONGLONG, &bytes);
_param_init_int (¶m[3], MYSQL_TYPE_FLOAT, &pct_cpu);
if (mysql_stmt_bind_param (db->ins_router_data, param)) {
if (lmt_conf_get_db_debug ())
msg ("error binding parameters for insert into %s ROUTER_DATA: %s",
lmt_db_fsname (db), mysql_error (db->conn));
goto done;
}
if (mysql_stmt_execute (db->ins_router_data)) {
if (mysql_errno (db->conn) == ER_DUP_ENTRY) {
retval = 0; /* expected failure if previous insert was delayed */
goto done;
}
if (lmt_conf_get_db_debug ())
msg ("error executing insert into %s ROUTER_DATA: %s",
lmt_db_fsname (db), mysql_error (db->conn));
goto done;
}
retval = 0;
done:
return retval;
}
static void verify_param_count(MYSQL_STMT *stmt, long exp_count)
{
long param_count= mysql_stmt_param_count(stmt);
if (!opt_silent)
fprintf(stdout, "\n total parameters in stmt: `%ld` (expected: `%ld`)",
param_count, exp_count);
DIE_UNLESS(param_count == exp_count);
}
bool MySqlPreparedStatement::prepare()
{
if(isPrepared())
return true;
//remove old binds
RemoveBinds();
//create statement object
m_stmt = mysql_stmt_init(m_pMySQLConn);
if (!m_stmt)
{
sLog.outError("SQL: mysql_stmt_init()() failed ");
return false;
}
//prepare statement
if (mysql_stmt_prepare(m_stmt, m_szFmt.c_str(), m_szFmt.length()))
{
sLog.outError("SQL: mysql_stmt_prepare() failed for '%s'", m_szFmt.c_str());
sLog.outError("SQL ERROR: %s", mysql_stmt_error(m_stmt));
return false;
}
/* Get the parameter count from the statement */
m_nParams = mysql_stmt_param_count(m_stmt);
/* Fetch result set meta information */
m_pResultMetadata = mysql_stmt_result_metadata(m_stmt);
//if we do not have result metadata
if (!m_pResultMetadata && strnicmp(m_szFmt.c_str(), "select", 6) == 0)
{
sLog.outError("SQL: no meta information for '%s'", m_szFmt.c_str());
sLog.outError("SQL ERROR: %s", mysql_stmt_error(m_stmt));
return false;
}
//bind input buffers
if(m_nParams)
{
m_pInputArgs = new MYSQL_BIND[m_nParams];
memset(m_pInputArgs, 0, sizeof(MYSQL_BIND) * m_nParams);
}
//check if we have a statement which returns result sets
if(m_pResultMetadata)
{
//our statement is query
m_bIsQuery = true;
/* Get total columns in the query */
m_nColumns = mysql_num_fields(m_pResultMetadata);
//bind output buffers
}
m_bPrepared = true;
return true;
}
void MySqlDataProvider::bindValue(int place, MYSQL_BIND* bind)
{
if (!mBind)
LOG_ERROR("MySqlDataProvider::bindValue: "
"Attempted to use an unprepared bind!");
else if (place > 0 && place <= (int)mysql_stmt_param_count(mStmt))
mBind[place - 1] = *bind;
else
LOG_ERROR("MySqlDataProvider::bindValue: "
"Attempted bind index out of range");
}
bool SqlCommand::Bind(SqlFieldParam* fieldParams, int number) {
int paramCount = mysql_stmt_param_count(m_stmt);
if (paramCount != number) {
m_sqlConnection.SetLastError("SqlCommand Bind Error << param number should be[%d]"
", but in[%d]", paramCount, number);
return false;
}
m_fieldParams = fieldParams;
m_fieldNumber = number;
return BindParams();
}
MySQLPreparedStatement::MySQLPreparedStatement(MYSQL_STMT* stmt) :
m_Mstmt(stmt), m_bind(NULL) {
/// Initialize variable parameters
m_paramCount = mysql_stmt_param_count(stmt);
m_paramsSet.assign(m_paramCount, false);
m_bind = new MYSQL_BIND[m_paramCount];
memset(m_bind, 0, sizeof(MYSQL_BIND) * m_paramCount);
/// "If set to 1, causes mysql_stmt_store_result() to update the metadata MYSQL_FIELD->max_length value."
my_bool bool_tmp = 1;
mysql_stmt_attr_set(stmt, STMT_ATTR_UPDATE_MAX_LENGTH, &bool_tmp);
}
int MySQLService::ExcuteBinary(const char *cmd, SQLParam *param)
{
MYSQL_BIND *bind = 0;
int err = 0;
MYSQL_STMT *stmt;
do
{
stmt = mysql_stmt_init(_connection);
if(!stmt)
break;
if(mysql_stmt_prepare(stmt, cmd, strlen(cmd)))
{
err = mysql_errno(_connection);
break;
}
uint32 count = mysql_stmt_param_count(stmt);
bind = new MYSQL_BIND[count];
memset(bind, 0, sizeof(bind) * count);
for(uint32 i = 0; i < count; i++)
{
bind[i].buffer = param[i].data;
bind[i].buffer_type = MYSQL_TYPE_BLOB;
bind[i].length= 0;
bind[i].buffer_length = param[i].length;
bind[i].is_null= 0;
if (mysql_stmt_bind_param(stmt, bind))
{
err = mysql_errno(_connection);
break;
}
}
if(!err)
{
if(mysql_stmt_execute(stmt))
{
err = mysql_errno(_connection);
}
}
}while(0);
if(stmt)
mysql_stmt_close(stmt);
delete [] bind;
return err;
}
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;
}
/**
* prepare_stmt - Initialize and prepare a query statement.
* @handle: connected handle
* @query: query statement string to execute
* @bind_parm: values for unbound variables (parameters) in @query
* @nparams: length of @bind_parms
* @bind_col: typed array to contain the column results
* ==> non-NULL 'is_null'/'error' fields are taken to mean
* that NULL values/errors are not acceptable
* @ncols: number of expected columns (length of @bind_col)
* Return prepared statement handle on success, NULL on error.
*/
MYSQL_STMT *prepare_stmt(MYSQL *handle, const char *query,
MYSQL_BIND bind_parm[], unsigned long nparams,
MYSQL_BIND bind_col[], unsigned long ncols)
{
MYSQL_STMT *stmt;
unsigned long param_count;
if (query == NULL || *query == '\0')
return NULL;
/* Initialize statement (fails only if out of memory). */
stmt = mysql_stmt_init(handle);
if (stmt == NULL) {
error("can not allocate handle for \"%s\"", query);
return NULL;
}
if (mysql_stmt_prepare(stmt, query, strlen(query))) {
error("can not prepare statement \"%s\": %s",
query, mysql_stmt_error(stmt));
goto prepare_failed;
}
/* Verify the parameter count */
param_count = mysql_stmt_param_count(stmt);
if (nparams != nparams) {
error("expected %lu parameters for \"%s\" but got %lu",
nparams, query, param_count);
goto prepare_failed;
}
if (!validate_stmt_column_count(stmt, query, ncols))
goto prepare_failed;
if (nparams && mysql_stmt_bind_param(stmt, bind_parm)) {
error("can not bind parameter buffers for \"%s\": %s",
query, mysql_stmt_error(stmt));
goto prepare_failed;
}
if (mysql_stmt_bind_result(stmt, bind_col)) {
error("can not bind output buffers for \"%s\": %s",
query, mysql_stmt_error(stmt));
goto prepare_failed;
}
return stmt;
prepare_failed:
(void)mysql_stmt_close(stmt);
return NULL;
}
MySQLPreparedStatement::MySQLPreparedStatement(MySQLConnection* conn, MYSQL_STMT* stmt) :
mysqlConn(conn),
closed(false),
stmt(stmt),
bind(NULL)
{
paramCount = mysql_stmt_param_count(stmt);
paramsSet.assign(paramCount, false);
bind = new MYSQL_BIND[paramCount];
ACE_OS::memset(bind, 0, sizeof(MYSQL_BIND) * paramCount);
my_bool bool_tmp=1;
mysql_stmt_attr_set(stmt, STMT_ATTR_UPDATE_MAX_LENGTH, &bool_tmp);
}
void StatementExecutor::bindParams(MYSQL_BIND* params, std::size_t count)
{
if (_state < STMT_COMPILED)
throw StatementException("Statement is not compiled yet");
if (count != mysql_stmt_param_count(_pHandle))
throw StatementException("wrong bind parameters count", 0, _query);
if (count == 0) return;
if (mysql_stmt_bind_param(_pHandle, params) != 0)
throw StatementException("mysql_stmt_bind_param() error ", _pHandle, _query);
}
void MySqlPreparedStatement::prepare()
{
if(isPrepared())
return;
//remove old binds
unprepare();
//create statement object
_myStmt = _mySqlConn._MySQLStmtInit();
poco_assert(_myStmt != nullptr);
//prepare statement
_mySqlConn._MySQLStmtPrepare(*this, _myStmt, _stmtSql, _stmtLen);
//Get the parameter count from the statement
_numParams = mysql_stmt_param_count(_myStmt);
//Fetch result set meta information
_myResMeta = mysql_stmt_result_metadata(_myStmt);
//if we do not have result metadata
if (!_myResMeta && (!strnicmp("select",_stmtSql,6)))
poco_bugcheck_msg(Poco::format("SQL: no meta information for '%s', ERROR %s",this->getSqlString(),this->lastErrorDescr()).c_str());
//set up bind input buffers
_myArgs.resize(_numParams);
for (size_t i=0;i<_myArgs.size();i++)
memset(&_myArgs[i], 0, sizeof(MYSQL_BIND));
//check if we have a statement which returns result sets
if(_myResMeta)
{
//our statement is a query
_isQuery = true;
//get number of columns of the query
_numColumns = mysql_num_fields(_myResMeta);
//set up bind output buffers
_myRes.resize(_numColumns);
for (size_t i=0;i<_myRes.size();i++)
{
MYSQL_BIND& curr = _myRes[i];
memset(&curr,0,sizeof(MYSQL_BIND));
//TODO: implement fetching results from statements
}
}
_prepared = true;
}
void wxMySQLRecordset::SetHandle(MYSQL_STMT * stmt)
{
m_Stmt = stmt;
m_HasResult = false;
if(m_Stmt)
{
printf("MYSQL_STMT_RESULT_METADATA\r\n");
MYSQL_RES * metadata_result = mysql_stmt_result_metadata(m_Stmt);
if(metadata_result)
{
m_HasResult = true;
SetFieldCount(mysql_num_fields(metadata_result));
mysql_free_result(metadata_result);
} else SetFieldCount(mysql_stmt_param_count(m_Stmt));
}
}
int wb_dbms_query::prepare(const char *query, int nResult, int nParam)
{
int rc = 0;
static const char *method = "prepare";
if (!m_prepared) {
m_query = query;
m_stmt = mysql_stmt_init(m_db->con());
if (m_stmt == 0) error(method, "mysql_stmt_init");
rc = mysql_stmt_prepare(m_stmt, query, strlen(query));
if (rc) error(rc, method, "mysql_stmt_prepare");
m_nParam = mysql_stmt_param_count(m_stmt);
m_nResult = mysql_stmt_field_count(m_stmt);
assert((m_nParam == nParam) && (m_nResult == nResult));
if (m_nParam > 0) {
m_param.bind = (MYSQL_BIND *)calloc(m_nParam, sizeof(MYSQL_BIND));
m_param.length = (size_t *)calloc(m_nParam, sizeof(size_t));
m_param.is_null = (my_bool *)calloc(m_nParam, sizeof(my_bool));
for (int i = m_nParam - 1; i >= 0; i--) {
m_param.bind[i].is_null = &m_param.is_null[i];
m_param.bind[i].length = (long unsigned int *)&m_param.length[i];
}
}
if (m_nResult > 0) {
m_result.bind = (MYSQL_BIND *)calloc(m_nResult, sizeof(MYSQL_BIND));
m_result.length = (size_t *)calloc(m_nParam, sizeof(size_t));
m_result.is_null = (my_bool *)calloc(m_nResult, sizeof(my_bool));
for (int i = m_nResult - 1; i >= 0; i--) {
m_result.bind[i].is_null = &m_result.is_null[i];
m_result.bind[i].length = (long unsigned int *)&m_result.length[i];
}
}
m_prepared = true;
}
return rc;
}
static int
_update_timestamp (lmt_db_t db)
{
MYSQL_BIND param[1];
uint64_t timestamp;
struct timeval tv;
int retval = -1;
assert (db->magic == LMT_DBHANDLE_MAGIC);
if (!db->ins_timestamp_info) {
errno = EPERM;
goto done;
}
/* N.B. Round timestamp down to nearest multiple of LMT_UPDATE_INTERVAL,
* seconds and don't insert a new entry if <= the last timestamp inserted.
* This keeps the number of rows in TIMESTAMP_INFO in check.
*/
if (gettimeofday (&tv, NULL) < 0)
goto done;
timestamp = tv.tv_sec;
timestamp -= (timestamp % LMT_UPDATE_INTERVAL);
if (timestamp <= db->timestamp) {
retval = 0;
goto done;
}
memset (param, 0, sizeof (param));
assert (mysql_stmt_param_count (db->ins_timestamp_info) == 1);
_param_init_int (¶m[0], MYSQL_TYPE_LONGLONG, ×tamp);
if (mysql_stmt_bind_param (db->ins_timestamp_info, param)) {
if (lmt_conf_get_db_debug ())
msg ("error binding params for insert into %s TIMESTAMP_INFO: %s",
lmt_db_fsname (db), mysql_error (db->conn));
goto done;
}
if (mysql_stmt_execute (db->ins_timestamp_info)) {
if (lmt_conf_get_db_debug ())
msg ("error executing insert into %s TIMESTAMP_INFO: %s",
lmt_db_fsname (db), mysql_error (db->conn));
goto done;
}
db->timestamp = timestamp;
db->timestamp_id = (uint64_t)mysql_insert_id (db->conn);
retval = 0;
done:
return retval;
}
bool MySqlDataProvider::prepareSql(const std::string &sql)
{
if (!mIsConnected)
return false;
LOG_DEBUG("MySqlDataProvider::prepareSql Preparing SQL statement: " << sql);
cleanBinds();
if (mysql_stmt_prepare(mStmt, sql.c_str(), sql.size()) != 0)
return false;
// Allocate bind memory now that the prepared state is done.
mBind = new MYSQL_BIND[(int)mysql_stmt_param_count(mStmt)];
return true;
}
Statement::Statement(MYSQL* conn, const string& sql)
{
m_conn = conn;
m_stmt = mysql_stmt_init(m_conn);
if(!m_stmt)
throw(MysqlException(ERRORS,"mysql_stmt_init error"));
m_state = STMT_INITED;
m_binder = NULL;
STMT_Throw(m_stmt,
mysql_stmt_prepare(m_stmt, sql.data(), sql.size())
);
int pc = mysql_stmt_param_count(m_stmt);
if (pc > 0)
m_binder = new Binder(pc);
m_state = STMT_COMPILED;
}
MySQLPreparedStatement(MySQLConnection *_conn, MySQLStatement *_stmt)
: conn(_conn), stmt(_stmt)
{
// Create bindings for input parameters
inputBindings.init(mysql_stmt_param_count(*stmt));
// And for results
res.setown(new MySQLResult(mysql_stmt_result_metadata(*stmt)));
if (*res)
{
resultBindings.bindResults(*res);
/* Bind the result buffers */
if (mysql_stmt_bind_result(*stmt, resultBindings.queryBindings()))
fail(mysql_stmt_error(*stmt));
}
else if (mysql_stmt_errno(*stmt)) // SQL actions don't return results...
fail(mysql_stmt_error(*stmt));
}
static int dbd_mysql_pvquery(apr_pool_t *pool, apr_dbd_t *sql, int *nrows,
apr_dbd_prepared_t *statement, va_list args)
{
MYSQL_BIND *bind;
char *arg;
int ret;
int nargs = 0;
int i;
my_bool is_null = FALSE;
if (sql->trans && sql->trans->errnum) {
return sql->trans->errnum;
}
nargs = mysql_stmt_param_count(statement->stmt);
bind = apr_palloc(pool, nargs*sizeof(MYSQL_BIND));
for (i=0; i < nargs; ++i) {
arg = va_arg(args, char*);
bind[i].buffer_type = MYSQL_TYPE_VAR_STRING;
bind[i].buffer = arg;
bind[i].buffer_length = strlen(arg);
bind[i].length = &bind[i].buffer_length;
bind[i].is_null = &is_null;
bind[i].is_unsigned = 0;
}
ret = mysql_stmt_bind_param(statement->stmt, bind);
if (ret != 0) {
*nrows = 0;
ret = mysql_stmt_errno(statement->stmt);
}
else {
ret = mysql_stmt_execute(statement->stmt);
if (ret != 0) {
ret = mysql_stmt_errno(statement->stmt);
}
*nrows = mysql_stmt_affected_rows(statement->stmt);
}
if (sql->trans) {
sql->trans->errnum = ret;
}
return ret;
}
MyStatement::MyStatement(MyDatabase *db, MYSQL_STMT *stmt)
: m_mysql(db->m_mysql), m_pParent(db), m_stmt(stmt), m_rs(NULL), m_Results(false)
{
m_Params = (unsigned int)mysql_stmt_param_count(m_stmt);
if (m_Params)
{
m_pushinfo = (ParamBind *)malloc(sizeof(ParamBind) * m_Params);
memset(m_pushinfo, 0, sizeof(ParamBind) * m_Params);
m_bind = (MYSQL_BIND *)malloc(sizeof(MYSQL_BIND) * m_Params);
memset(m_bind, 0, sizeof(MYSQL_BIND) * m_Params);
} else {
m_pushinfo = NULL;
m_bind = NULL;
}
m_pRes = mysql_stmt_result_metadata(stmt);
m_Results = false;
}
MYSQL_STMT *db_stmt_prepare(MYSQL_STMT *stmt, MYSQL *con, const char *sql, const int para_num){
// init the statement
if((stmt = mysql_stmt_init(con)) == NULL){
printf("Mysql statement initialization failed.\n");
exit(0);
}
// combine the statement with the sql
if(mysql_stmt_prepare(stmt, sql, strlen(sql))){
printf("mysql_stmt_prepare(), INSERT failed\n");
printf("%s", mysql_stmt_error(stmt));
exit(0);
}
// ensure the parameter number is correct
if(mysql_stmt_param_count(stmt) != para_num){
printf("invalid parameter count returned by MySQL\n");
exit(0);
}
return stmt;
}
std::pair<unsigned, MError> MMysqlCommand::DoExecuteNonQuery()
{
int param_count = mysql_stmt_param_count(p_stmt_);
if (static_cast<size_t>(param_count) != in_params_.size())
{
MLOG(MGetLibLogger(), MERR, "param count is not match need:", param_count, " actual is:", in_params_.size());
return std::pair<unsigned, MError>(0, MError::NotMatch);
}
if (mysql_stmt_bind_param(p_stmt_, &in_params_[0]) != 0)
{
MLOG(MGetLibLogger(), MERR, "bind failed errno:", mysql_stmt_errno(p_stmt_), " error:", mysql_stmt_error(p_stmt_));
return std::pair<unsigned, MError>(0, MError::Unknown);
}
if (mysql_stmt_execute(p_stmt_) != 0)
{
MLOG(MGetLibLogger(), MERR, "execute failed errorno:", mysql_stmt_errno(p_stmt_), " error:", mysql_stmt_error(p_stmt_));
return std::pair<unsigned, MError>(0, MError::Unknown);
}
unsigned affect = mysql_stmt_affected_rows(p_stmt_);
return std::make_pair(affect, MError::No);
}
MError MMysqlCommand::DoExecuteReader()
{
int param_count = mysql_stmt_param_count(p_stmt_);
if (static_cast<size_t>(param_count) != in_params_.size())
{
MLOG(MGetLibLogger(), MERR, "param count is not match need:", param_count, " actual is :", in_params_.size());
return MError::NotMatch;
}
if (mysql_stmt_bind_param(p_stmt_, &in_params_[0]) != 0)
{
MLOG(MGetLibLogger(), MERR, "bind failed errno:", mysql_stmt_errno(p_stmt_), " error:", mysql_stmt_error(p_stmt_));
return MError::Unknown;
}
my_bool update_max_length = 1;
mysql_stmt_attr_set(p_stmt_, STMT_ATTR_UPDATE_MAX_LENGTH, static_cast<void*>(&update_max_length));
if (mysql_stmt_execute(p_stmt_) != 0)
{
MLOG(MGetLibLogger(), MERR, "execute failed errno:", mysql_stmt_errno(p_stmt_), " error:", mysql_stmt_error(p_stmt_));
return MError::Unknown;
}
return BindResult();
}
bool SqlStatement::run()
{
TRACE("run: %s", query_);
if (bindOffset_ != mysql_stmt_param_count(stmt_)) {
error_ = "Invalid parameter count";
fprintf(stderr, "Cannot run argument with invalid parameter count.\n");
return false;
}
if (paramCount_ != 0 && mysql_stmt_bind_param(stmt_, params_) != 0) {
error_ = mysql_stmt_error(stmt_);
return false;
}
unsigned i = 0;
for (bool done = false; !done; i = 1 + i % 10) {
switch (mysql_stmt_execute(stmt_)) {
case CR_SERVER_GONE_ERROR:
case CR_SERVER_LOST_EXTENDED:
case CR_SERVER_LOST:
if (i)
sleep(i);
break;
case 0:
done = true;
break;
default:
error_ = mysql_stmt_error(stmt_);
fprintf(stderr, "sql: statement execution error: %s\n", error_);
return false;
}
}
mysql_stmt_store_result(stmt_);
error_ = nullptr;
return true;
}
static MYSQL_STMT *
table_mysql_prepare_stmt(MYSQL *_db, const char *query, unsigned long nparams,
unsigned int nfields)
{
MYSQL_STMT *stmt;
if ((stmt = mysql_stmt_init(_db)) == NULL) {
log_warnx("warn: table-mysql: mysql_stmt_init: %s",
mysql_error(_db));
goto end;
}
if (mysql_stmt_prepare(stmt, query, strlen(query))) {
log_warnx("warn: table-mysql: mysql_stmt_prepare: %s",
mysql_stmt_error(stmt));
goto end;
}
if (mysql_stmt_param_count(stmt) != nparams) {
log_warnx("warn: table-mysql: wrong number of params for %s", query);
goto end;
}
if (mysql_stmt_field_count(stmt) != nfields) {
log_warnx("warn: table-mysql: wrong number of columns in resultset");
goto end;
}
if (mysql_stmt_bind_result(stmt, results)) {
log_warnx("warn: table-mysql: mysql_stmt_bind_results: %s",
mysql_stmt_error(stmt));
goto end;
}
return (stmt);
end:
if (stmt)
mysql_stmt_close(stmt);
return (NULL);
}
