/* call-seq: client.prepare # => Mysql2::Statement
*
* Create a new prepared statement.
*/
static VALUE prepare_statement(VALUE self, VALUE sql) {
GET_CLIENT(self);
struct nogvl_prepare_statement_args args;
MYSQL_STMT *stmt;
VALUE rb_stmt;
my_bool truth = 1;
stmt = mysql_stmt_init(wrapper->client);
if (stmt == NULL) {
rb_raise(cMysql2Error, "Unable to initialize prepared statement: out of memory");
}
if (mysql_stmt_attr_set(stmt, STMT_ATTR_UPDATE_MAX_LENGTH, &truth)) {
rb_raise(cMysql2Error, "Unable to initialize prepared statement");
}
rb_stmt = Data_Wrap_Struct(cMysql2Statement, 0, mysql_stmt_close, stmt);
args.stmt = stmt;
args.sql = StringValuePtr(sql);
args.sql_len = RSTRING_LEN(sql);
if (rb_thread_blocking_region(nogvl_prepare_statement, &args, RUBY_UBF_IO, 0) == Qfalse) {
rb_raise(cMysql2Error, "%s", mysql_stmt_error(stmt));
}
return rb_stmt;
}
bool MySQLPreparedStatement::execute()
{
doQuery();
my_bool bool_tmp=1;
mysql_stmt_attr_set(stmt, STMT_ATTR_UPDATE_MAX_LENGTH, &bool_tmp);
//mysql_stmt_store_result(stmt);
return (mysql_stmt_field_count(stmt) > 0);
}
VALUE rb_mysql_stmt_new(VALUE rb_client, VALUE sql) {
mysql_stmt_wrapper *stmt_wrapper;
VALUE rb_stmt;
#ifdef HAVE_RUBY_ENCODING_H
rb_encoding *conn_enc;
#endif
Check_Type(sql, T_STRING);
rb_stmt = Data_Make_Struct(cMysql2Statement, mysql_stmt_wrapper, rb_mysql_stmt_mark, rb_mysql_stmt_free, stmt_wrapper);
{
stmt_wrapper->client = rb_client;
stmt_wrapper->refcount = 1;
stmt_wrapper->closed = 0;
stmt_wrapper->stmt = NULL;
}
// instantiate stmt
{
GET_CLIENT(rb_client);
stmt_wrapper->stmt = mysql_stmt_init(wrapper->client);
#ifdef HAVE_RUBY_ENCODING_H
conn_enc = rb_to_encoding(wrapper->encoding);
#endif
}
if (stmt_wrapper->stmt == NULL) {
rb_raise(cMysql2Error, "Unable to initialize prepared statement: out of memory");
}
// set STMT_ATTR_UPDATE_MAX_LENGTH attr
{
my_bool truth = 1;
if (mysql_stmt_attr_set(stmt_wrapper->stmt, STMT_ATTR_UPDATE_MAX_LENGTH, &truth)) {
rb_raise(cMysql2Error, "Unable to initialize prepared statement: set STMT_ATTR_UPDATE_MAX_LENGTH");
}
}
// call mysql_stmt_prepare w/o gvl
{
struct nogvl_prepare_statement_args args;
args.stmt = stmt_wrapper->stmt;
args.sql = sql;
#ifdef HAVE_RUBY_ENCODING_H
// ensure the string is in the encoding the connection is expecting
args.sql = rb_str_export_to_enc(args.sql, conn_enc);
#endif
args.sql_ptr = RSTRING_PTR(sql);
args.sql_len = RSTRING_LEN(sql);
if ((VALUE)rb_thread_call_without_gvl(nogvl_prepare_statement, &args, RUBY_UBF_IO, 0) == Qfalse) {
rb_raise_mysql2_stmt_error(stmt_wrapper);
}
}
return rb_stmt;
}
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);
}
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);
}
ResultSet_T MysqlPreparedStatement_executeQuery(T P) {
assert(P);
if (P->parameterCount > 0)
if ((P->lastError = mysql_stmt_bind_param(P->stmt, P->bind)))
THROW(SQLException, "%s", mysql_stmt_error(P->stmt));
#if MYSQL_VERSION_ID >= 50002
unsigned long cursor = CURSOR_TYPE_READ_ONLY;
mysql_stmt_attr_set(P->stmt, STMT_ATTR_CURSOR_TYPE, &cursor);
#endif
if ((P->lastError = mysql_stmt_execute(P->stmt)))
THROW(SQLException, "%s", mysql_stmt_error(P->stmt));
if (P->lastError == MYSQL_OK)
return ResultSet_new(MysqlResultSet_new(P->stmt, P->maxRows, true), (Rop_T)&mysqlrops);
THROW(SQLException, "%s", mysql_stmt_error(P->stmt));
return NULL;
}
void MysqlPreparedStatement_execute(T P) {
assert(P);
if (P->parameterCount > 0)
if ((P->lastError = mysql_stmt_bind_param(P->stmt, P->bind)))
THROW(SQLException, "%s", mysql_stmt_error(P->stmt));
#if MYSQL_VERSION_ID >= 50002
unsigned long cursor = CURSOR_TYPE_NO_CURSOR;
mysql_stmt_attr_set(P->stmt, STMT_ATTR_CURSOR_TYPE, &cursor);
#endif
if ((P->lastError = mysql_stmt_execute(P->stmt)))
THROW(SQLException, "%s", mysql_stmt_error(P->stmt));
if (P->lastError == MYSQL_OK) {
/* Discard prepared param data in client/server */
P->lastError = mysql_stmt_reset(P->stmt);
}
}
MYSQL_STMT* MADB_NewStmtHandle(MADB_Stmt *Stmt)
{
static const my_bool UpdateMaxLength= 1;
MYSQL_STMT* stmt= mysql_stmt_init(Stmt->Connection->mariadb);
if (stmt != NULL)
{
mysql_stmt_attr_set(stmt, STMT_ATTR_UPDATE_MAX_LENGTH, &UpdateMaxLength);
}
else
{
MADB_SetError(&Stmt->Error, MADB_ERR_HY001, NULL, 0);
}
return stmt;
}
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();
}
ResultSet_T MysqlConnection_executeQuery(T C, const char *sql, va_list ap) {
va_list ap_copy;
MYSQL_STMT *stmt = NULL;
assert(C);
StringBuffer_clear(C->sb);
va_copy(ap_copy, ap);
StringBuffer_vappend(C->sb, sql, ap_copy);
va_end(ap_copy);
if (prepare(C, StringBuffer_toString(C->sb), StringBuffer_length(C->sb), &stmt)) {
#if MYSQL_VERSION_ID >= 50002
unsigned long cursor = CURSOR_TYPE_READ_ONLY;
mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, &cursor);
#endif
if ((C->lastError = mysql_stmt_execute(stmt))) {
StringBuffer_clear(C->sb);
StringBuffer_append(C->sb, "%s", mysql_stmt_error(stmt));
mysql_stmt_close(stmt);
}
else
return ResultSet_new(MysqlResultSet_new(stmt, C->maxRows, false), (Rop_T)&mysqlrops);
}
return NULL;
}
void
gda_mysql_recordset_set_chunk_size (GdaMysqlRecordset *recset,
gint chunk_size)
{
g_return_if_fail (GDA_IS_MYSQL_RECORDSET (recset));
if (recset->priv->mysql_stmt == NULL) // Creation is in progress so it's not set.
return;
#if MYSQL_VERSION_ID >= 50002
const unsigned long prefetch_rows = chunk_size;
if (mysql_stmt_attr_set (recset->priv->mysql_stmt, STMT_ATTR_PREFETCH_ROWS,
(void *) &prefetch_rows)) {
g_warning ("%s: %s\n", __func__, mysql_stmt_error (recset->priv->mysql_stmt));
return;
}
recset->priv->chunk_size = chunk_size;
g_object_notify (G_OBJECT(recset), "chunk-size");
#else
g_warning (_("Could not use CURSOR. Mysql version 5.0 at least is required. "
"Chunk size ignored."));
#endif
}
static GtRDBStmt* gt_rdb_mysql_prepare(GtRDB *rdb, const char *query,
GtUword num_params, GtError *err)
{
GtRDBStmt *st = NULL;
GtRDBStmtMySQL *stm = NULL;
GtRDBMySQL *rdbm;
int had_err = 0, retval = 0;
/* we need these to keep track of result/parameter and string buffers */
HashElemInfo str_buffer_hash = {
gt_ht_ptr_elem_hash,
{ free_str },
sizeof (GtStr*),
gt_ht_ptr_elem_cmp,
NULL,
NULL
},
buffer_hash = {
gt_ht_ptr_elem_hash,
{ free_buf },
sizeof (void*),
gt_ht_ptr_elem_cmp,
NULL,
NULL
};
MYSQL_STMT *tmp = NULL;
gt_assert(rdb && query);
gt_error_check(err);
rdbm = gt_rdb_mysql_cast(rdb);
tmp = mysql_stmt_init(&rdbm->conn);
if ((retval = mysql_stmt_prepare(tmp, query, strlen(query)))) {
gt_error_set(err, GT_MYSQL_ERRMSG, retval, mysql_stmt_error(tmp));
had_err = -1;
}
if (!had_err) {
int param_count;
param_count = mysql_stmt_param_count(tmp);
if (param_count != num_params) {
gt_error_set(err, "invalid parameter count: "GT_WU" expected, %d given",
num_params, param_count);
mysql_stmt_close(tmp);
had_err = -1;
}
}
if (!had_err) {
st = gt_rdb_stmt_create(gt_rdb_stmt_mysql_class());
stm = gt_rdb_stmt_mysql_cast(st);
stm->num_params = num_params;
stm->query = gt_str_new_cstr(query);
stm->buffers = gt_hashtable_new(buffer_hash);
stm->returned_strings = gt_hashtable_new(str_buffer_hash);
stm->stmt = tmp;
stm->update_maxlengths = true;
stm->params = gt_calloc(num_params, sizeof (MYSQL_BIND));
mysql_stmt_attr_set(tmp, STMT_ATTR_UPDATE_MAX_LENGTH,
&stm->update_maxlengths);
memset(stm->params, 0, num_params*sizeof (MYSQL_BIND));
stm->conn = &rdbm->conn;
}
return st;
}
static int my_process_stmt_result(MYSQL_STMT *stmt)
{
int field_count;
int row_count= 0;
MYSQL_BIND buffer[MAX_RES_FIELDS];
MYSQL_FIELD *field;
MYSQL_RES *result;
char data[MAX_RES_FIELDS][MAX_FIELD_DATA_SIZE];
ulong length[MAX_RES_FIELDS];
my_bool is_null[MAX_RES_FIELDS];
int rc, i;
if (!(result= mysql_stmt_result_metadata(stmt))) /* No meta info */
{
while (!mysql_stmt_fetch(stmt))
row_count++;
return row_count;
}
field_count= MY_MIN(mysql_num_fields(result), MAX_RES_FIELDS);
memset(buffer, 0, sizeof(buffer));
memset(length, 0, sizeof(length));
memset(is_null, 0, sizeof(is_null));
for(i= 0; i < field_count; i++)
{
buffer[i].buffer_type= MYSQL_TYPE_STRING;
buffer[i].buffer_length= MAX_FIELD_DATA_SIZE;
buffer[i].length= &length[i];
buffer[i].buffer= (void *) data[i];
buffer[i].is_null= &is_null[i];
}
rc= mysql_stmt_bind_result(stmt, buffer);
check_execute(stmt, rc);
rc= 1;
mysql_stmt_attr_set(stmt, STMT_ATTR_UPDATE_MAX_LENGTH, (void*)&rc);
rc= mysql_stmt_store_result(stmt);
check_execute(stmt, rc);
my_print_result_metadata(result);
mysql_field_seek(result, 0);
while ((rc= mysql_stmt_fetch(stmt)) == 0)
{
if (!opt_silent)
{
fputc('\t', stdout);
fputc('|', stdout);
}
mysql_field_seek(result, 0);
for (i= 0; i < field_count; i++)
{
field= mysql_fetch_field(result);
if (!opt_silent)
{
if (is_null[i])
fprintf(stdout, " %-*s |", (int) field->max_length, "NULL");
else if (length[i] == 0)
{
data[i][0]= '\0'; /* unmodified buffer */
fprintf(stdout, " %*s |", (int) field->max_length, data[i]);
}
else if (IS_NUM(field->type))
fprintf(stdout, " %*s |", (int) field->max_length, data[i]);
else
fprintf(stdout, " %-*s |", (int) field->max_length, data[i]);
}
}
if (!opt_silent)
{
fputc('\t', stdout);
fputc('\n', stdout);
}
row_count++;
}
DIE_UNLESS(rc == MYSQL_NO_DATA);
if (!opt_silent)
{
if (row_count)
my_print_dashes(result);
fprintf(stdout, "\n\t%d %s returned\n", row_count,
row_count == 1 ? "row" : "rows");
}
mysql_free_result(result);
return row_count;
}
void stmt_fetch_init(Stmt_fetch *fetch, unsigned stmt_no_arg,
const char *query_arg)
{
unsigned long type= CURSOR_TYPE_READ_ONLY;
int rc;
unsigned i;
MYSQL_RES *metadata;
DBUG_ENTER("stmt_fetch_init");
/* Save query and statement number for error messages */
fetch->stmt_no= stmt_no_arg;
fetch->query= query_arg;
fetch->handle= mysql_stmt_init(mysql);
rc= mysql_stmt_prepare(fetch->handle, fetch->query, (ulong)strlen(fetch->query));
check_execute(fetch->handle, rc);
/*
The attribute is sent to server on execute and asks to open read-only
for result set
*/
mysql_stmt_attr_set(fetch->handle, STMT_ATTR_CURSOR_TYPE,
(const void*) &type);
rc= mysql_stmt_execute(fetch->handle);
check_execute(fetch->handle, rc);
/* Find out total number of columns in result set */
metadata= mysql_stmt_result_metadata(fetch->handle);
fetch->column_count= mysql_num_fields(metadata);
mysql_free_result(metadata);
/*
Now allocate bind handles and buffers for output data:
calloc memory to reduce number of MYSQL_BIND members we need to
set up.
*/
fetch->bind_array= (MYSQL_BIND *) calloc(1, sizeof(MYSQL_BIND) *
fetch->column_count);
fetch->out_data= (char**) calloc(1, sizeof(char*) * fetch->column_count);
fetch->out_data_length= (ulong*) calloc(1, sizeof(ulong) *
fetch->column_count);
for (i= 0; i < fetch->column_count; ++i)
{
fetch->out_data[i]= (char*) calloc(1, MAX_COLUMN_LENGTH);
fetch->bind_array[i].buffer_type= MYSQL_TYPE_STRING;
fetch->bind_array[i].buffer= fetch->out_data[i];
fetch->bind_array[i].buffer_length= MAX_COLUMN_LENGTH;
fetch->bind_array[i].length= fetch->out_data_length + i;
}
mysql_stmt_bind_result(fetch->handle, fetch->bind_array);
fetch->row_count= 0;
fetch->is_open= TRUE;
/* Ready for reading rows */
DBUG_VOID_RETURN;
}
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;
}
int sqlrow(DB db,SQL sql,const char *format,...)
{
int i;
my_bool w;
int *ii;
char **t;
MYSQL_FIELD *f;
va_list ap;
if(!db||!sql)
{
printf("sqlrow: bad database/query handle\n");
return -1;
}
if(!sql->result)
{
w=1;
if(mysql_stmt_attr_set(sql->sql,STMT_ATTR_UPDATE_MAX_LENGTH,&w))
{
printf("sqlsetattr: %s\n",mysql_stmt_error(sql->sql));
goto out0;
}
if(mysql_stmt_execute(sql->sql))
{
printf("sqlexecute: %s\n",mysql_stmt_error(sql->sql));
goto out0;
}
if(!(sql->restotal=mysql_stmt_field_count(sql->sql)))return 1;
if(mysql_stmt_store_result(sql->sql))
{
printf("sqlstore: %s\n",mysql_stmt_error(sql->sql));
goto out0;
}
if(!(sql->result=mysql_stmt_result_metadata(sql->sql)))return 1;
if(!(f=mysql_fetch_fields(sql->result)))
{
printf("sqlfields: %s\n",mysql_stmt_error(sql->sql));
goto out0;
}
if(!(sql->reslbuf=malloc(sql->restotal*sizeof(unsigned long))))
{
printf("sqlrow: out of memory\n");
goto out0;
}
if(!(sql->resibuf=malloc(sql->restotal*sizeof(int))))
{
printf("sqlrow: out of memory\n");
goto out0;
}
if(!(sql->resparam=malloc(sql->restotal*sizeof(MYSQL_BIND))))
{
printf("sqlrow: out of memory\n");
goto out0;
}
memset(sql->resparam,0,sql->restotal*sizeof(MYSQL_BIND));
for(i=0;i<sql->restotal;i++)switch(f[i].type)
{
case FIELD_TYPE_TINY:
case FIELD_TYPE_SHORT:
case FIELD_TYPE_LONG:
case FIELD_TYPE_LONGLONG:
case FIELD_TYPE_INT24:
sql->resparam[i].buffer_type=MYSQL_TYPE_LONG;
sql->resparam[i].buffer=&sql->resibuf[i];
break;
case FIELD_TYPE_STRING:
case FIELD_TYPE_VAR_STRING:
case FIELD_TYPE_BLOB:
sql->resparam[i].buffer_type=MYSQL_TYPE_BLOB;
sql->resparam[i].buffer_length=f[i].max_length+1;
sql->resparam[i].length=&sql->reslbuf[i];
if(!(sql->resparam[i].buffer=malloc(f[i].max_length+1)))
{
while(i--)if(sql->resparam[i].buffer_type==
MYSQL_TYPE_BLOB)
free(sql->resparam[i].buffer);
free(sql->resparam);
sql->resparam=NULL;
printf("sqlrow: out of memory\n");
goto out0;
}
break;
default:
printf("sqlrow: unknown field type %d\n",f[i].type);
return -1;
}
if(mysql_stmt_bind_result(sql->sql,sql->resparam))
{
printf("sqlresbind: %s\n",mysql_stmt_error(sql->sql));
goto out0;
}
}
if(mysql_stmt_fetch(sql->sql))return 1;
va_start(ap,format);
for(i=0;*format;i++)if(i==sql->restotal)
{
va_end(ap);
goto out1;
}
else switch(*format++)
{
case 'i':
if(sql->resparam[i].buffer_type!=MYSQL_TYPE_LONG)
{
va_end(ap);
goto out1;
}
ii=va_arg(ap,int *);
*ii=sql->resibuf[i];
break;
break;
case 't':
if(sql->resparam[i].buffer_type!=MYSQL_TYPE_BLOB)
{
va_end(ap);
goto out1;
}
t=va_arg(ap,char **);
*t=sql->resparam[i].buffer;
(*t)[sql->reslbuf[i]]=0;
break;
default:printf("unknown format %c\n",format[-1]);
va_end(ap);
goto out0;
}
va_end(ap);
return 0;
out1: printf("sqlrow format mismatch\n");
out0: return -1;
}
void Statement::Prepare() {
if (! _db.IsConnected()) {
throw DatabaseException("Error in Statement::Prepare", 0, "----", "Database is not connected");
}
_numberAffectedRows = 0;
if ((_stmt = mysql_stmt_init(_db._db)) == NULL) {
throw DatabaseException(_db._db, "Error in Statement::Prepare during initialize");
}
if (mysql_stmt_prepare(_stmt, _sqlStatement.c_str(), _sqlStatement.length()) != 0) {
mysql_stmt_close(_stmt);
throw DatabaseException(_stmt, "Error in Statement::Prepare during prepare");
}
_bind = NULL;
unsigned long parameterCount = ParameterCount();
if (parameterCount > 0) {
_bind = (MYSQL_BIND *) malloc(sizeof(MYSQL_BIND) * parameterCount);
memset(_bind, 0, sizeof(MYSQL_BIND) * parameterCount);
}
_numberResultColumns = 0;
_hasBlobField = false;
MYSQL_RES *metaData;
if ((metaData = mysql_stmt_result_metadata(_stmt)) == NULL) {
return;
}
_resultBind = NULL;
_numberResultColumns = mysql_num_fields(metaData);
if (_numberResultColumns > 0) {
_resultBind = (MYSQL_BIND *) malloc(sizeof(MYSQL_BIND) * _numberResultColumns);
memset(_resultBind, 0, sizeof(MYSQL_BIND) * _numberResultColumns);
}
int fieldPos = 0;
MYSQL_FIELD *field;
while ((field = mysql_fetch_field(metaData)) != NULL) {
ParamBuffer *buffer = NULL;
if ((field->type == MYSQL_TYPE_VAR_STRING) ||
(field->type == MYSQL_TYPE_STRING) ||
(field->type == MYSQL_TYPE_DECIMAL) ||
(field->type == MYSQL_TYPE_BIT) ||
(field->type == MYSQL_TYPE_VARCHAR)) {
std::string str;
buffer = new ParamBuffer(str, field->length);
_resultBind[fieldPos].buffer_type = field->type;
_resultBind[fieldPos].buffer = buffer->Buffer();
_resultBind[fieldPos].buffer_length = buffer->BufferSize();
_resultBind[fieldPos].length = buffer->BufferLength();
_resultBind[fieldPos].is_null = buffer->IsNull();
_resultBind[fieldPos].error = buffer->Error();
}
else if (field->type == MYSQL_TYPE_TINY) {
if ((field->flags & UNSIGNED_FLAG) != 0) {
buffer = new ParamBuffer((const unsigned char) 0);
} else {
buffer = new ParamBuffer((const char) 0);
}
_resultBind[fieldPos].buffer_type = MYSQL_TYPE_TINY;
_resultBind[fieldPos].buffer = buffer->Buffer();
_resultBind[fieldPos].buffer_length = buffer->BufferSize();
_resultBind[fieldPos].length = buffer->BufferLength();
_resultBind[fieldPos].is_null = buffer->IsNull();
_resultBind[fieldPos].error = buffer->Error();
_resultBind[fieldPos].is_unsigned = buffer->IsUnsigned();
}
else if ((field->type == MYSQL_TYPE_SHORT) ||
(field->type == MYSQL_TYPE_YEAR)) {
if ((field->flags & UNSIGNED_FLAG) != 0) {
buffer = new ParamBuffer((const unsigned short int) 0);
} else {
buffer = new ParamBuffer((const short int) 0);
}
_resultBind[fieldPos].buffer_type = MYSQL_TYPE_SHORT;
_resultBind[fieldPos].buffer = buffer->Buffer();
_resultBind[fieldPos].buffer_length = buffer->BufferSize();
_resultBind[fieldPos].length = buffer->BufferLength();
_resultBind[fieldPos].is_null = buffer->IsNull();
_resultBind[fieldPos].error = buffer->Error();
_resultBind[fieldPos].is_unsigned = buffer->IsUnsigned();
}
else if ((field->type == MYSQL_TYPE_LONG) ||
(field->type == MYSQL_TYPE_INT24)) {
if ((field->flags & UNSIGNED_FLAG) != 0) {
buffer = new ParamBuffer((const unsigned int) 0);
} else {
buffer = new ParamBuffer((const int) 0);
}
_resultBind[fieldPos].buffer_type = field->type;
_resultBind[fieldPos].buffer = buffer->Buffer();
_resultBind[fieldPos].buffer_length = buffer->BufferSize();
_resultBind[fieldPos].length = buffer->BufferLength();
_resultBind[fieldPos].is_null = buffer->IsNull();
_resultBind[fieldPos].error = buffer->Error();
_resultBind[fieldPos].is_unsigned = buffer->IsUnsigned();
}
else if (field->type == MYSQL_TYPE_FLOAT) {
_resultBind[fieldPos].buffer_type = field->type;
_resultBind[fieldPos].buffer = buffer->Buffer();
_resultBind[fieldPos].buffer_length = buffer->BufferSize();
_resultBind[fieldPos].length = buffer->BufferLength();
_resultBind[fieldPos].is_null = buffer->IsNull();
_resultBind[fieldPos].error = buffer->Error();
_resultBind[fieldPos].is_unsigned = buffer->IsUnsigned();
}
else if (field->type == MYSQL_TYPE_DOUBLE) {
_resultBind[fieldPos].buffer_type = field->type;
_resultBind[fieldPos].buffer = buffer->Buffer();
_resultBind[fieldPos].buffer_length = buffer->BufferSize();
_resultBind[fieldPos].length = buffer->BufferLength();
_resultBind[fieldPos].is_null = buffer->IsNull();
_resultBind[fieldPos].error = buffer->Error();
_resultBind[fieldPos].is_unsigned = buffer->IsUnsigned();
}
else if ((field->type == MYSQL_TYPE_TIMESTAMP) ||
(field->type == MYSQL_TYPE_DATE) ||
(field->type == MYSQL_TYPE_TIME) ||
(field->type == MYSQL_TYPE_DATETIME)) {
Julian time;
buffer = new ParamBuffer(time);
_resultBind[fieldPos].buffer_type = field->type;
_resultBind[fieldPos].buffer = buffer->Buffer();
_resultBind[fieldPos].buffer_length = buffer->BufferSize();
_resultBind[fieldPos].length = buffer->BufferLength();
_resultBind[fieldPos].is_null = buffer->IsNull();
_resultBind[fieldPos].error = buffer->Error();
}
else if ((field->type == MYSQL_TYPE_BLOB) ||
(field->type == MYSQL_TYPE_TINY_BLOB) ||
(field->type == MYSQL_TYPE_MEDIUM_BLOB) ||
(field->type == MYSQL_TYPE_LONG_BLOB)) {
_hasBlobField = true;
Binary data(field->length);
buffer = new ParamBuffer(data);
_resultBind[fieldPos].buffer_type = field->type;
_resultBind[fieldPos].buffer = buffer->Buffer();
_resultBind[fieldPos].buffer_length = buffer->BufferSize();
_resultBind[fieldPos].length = buffer->BufferLength();
_resultBind[fieldPos].is_null = buffer->IsNull();
_resultBind[fieldPos].error = buffer->Error();
}
if (buffer != NULL) {
_resultParams.push_back(buffer);
}
fieldPos++;
}
if (_resultParams.size() != _numberResultColumns) {
mysql_free_result(metaData);
mysql_stmt_close(_stmt);
throw DatabaseException("Error in Statement::Prepare", 0, "----", "was not able to bind all parameters");
}
if (_hasBlobField) {
my_bool setMax = 1;
mysql_stmt_attr_set(_stmt, STMT_ATTR_UPDATE_MAX_LENGTH, &setMax);
}
if (_numberResultColumns > 0) {
if (mysql_stmt_bind_result(_stmt, _resultBind) != 0) {
mysql_free_result(metaData);
mysql_stmt_close(_stmt);
throw DatabaseException(_stmt, "Error in Statement::Prepare while binding results");
}
}
mysql_free_result(metaData);
}
int main (int argc, char *argv[]) {
MYSQL *mysql;
MYSQL_RES *result;
MYSQL_ROW row;
my_bool reconnect = 0;
mysql = mysql_init(NULL);
mysql_options(mysql, MYSQL_OPT_RECONNECT, &reconnect);
CONN(0);
MYSQL_STMT *stmt;
MYSQL_BIND bind[1];
MYSQL_RES *prepare_meta_result;
MYSQL_TIME ts;
unsigned long length[1];
int param_count, column_count, row_count;
short small_data;
int int_data;
char str_data[STRING_SIZE];
my_bool is_null[1];
// 1. no cursor
stmt = mysql_stmt_init(mysql);
mysql_stmt_prepare(stmt, SELECT_SAMPLE, strlen(SELECT_SAMPLE));
param_count= mysql_stmt_param_count(stmt);
//prepare_meta_result = mysql_stmt_result_metadata(stmt);
mysql_stmt_execute(stmt);
memset(bind, 0, sizeof(bind));
bind[0].buffer_type= MYSQL_TYPE_LONG;
bind[0].buffer= (char *)&int_data;
bind[0].is_null= &is_null[0];
bind[0].length= &length[0];
mysql_stmt_bind_result(stmt, bind);
//mysql_stmt_store_result(stmt);
while (!mysql_stmt_fetch(stmt)) {
printf("1 - %d \n", int_data);
}
mysql_stmt_close(stmt);
// 2. cursor read only
stmt = mysql_stmt_init(mysql);
unsigned long type = (unsigned long) CURSOR_TYPE_READ_ONLY;
mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, (void*) &type);
mysql_stmt_prepare(stmt, SELECT_SAMPLE, strlen(SELECT_SAMPLE));
param_count= mysql_stmt_param_count(stmt);
//prepare_meta_result = mysql_stmt_result_metadata(stmt);
mysql_stmt_execute(stmt);
memset(bind, 0, sizeof(bind));
bind[0].buffer_type= MYSQL_TYPE_LONG;
bind[0].buffer= (char *)&int_data;
bind[0].is_null= &is_null[0];
bind[0].length= &length[0];
mysql_stmt_bind_result(stmt, bind);
//mysql_stmt_store_result(stmt); // default 1
while (!mysql_stmt_fetch(stmt)) {
printf("1 - %d \n", int_data);
}
mysql_stmt_close(stmt);
// 3. set num
stmt = mysql_stmt_init(mysql);
type = (unsigned long) CURSOR_TYPE_READ_ONLY;
unsigned long prefetch_rows = 2;
mysql_stmt_attr_set(stmt, STMT_ATTR_CURSOR_TYPE, (void*) &type);
mysql_stmt_attr_set(stmt, STMT_ATTR_PREFETCH_ROWS, (void*) &prefetch_rows);
mysql_stmt_prepare(stmt, SELECT_SAMPLE, strlen(SELECT_SAMPLE));
param_count= mysql_stmt_param_count(stmt);
//prepare_meta_result = mysql_stmt_result_metadata(stmt);
mysql_stmt_execute(stmt);
memset(bind, 0, sizeof(bind));
bind[0].buffer_type= MYSQL_TYPE_LONG;
bind[0].buffer= (char *)&int_data;
bind[0].is_null= &is_null[0];
bind[0].length= &length[0];
mysql_stmt_bind_result(stmt, bind);
//mysql_stmt_store_result(stmt);
while (!mysql_stmt_fetch(stmt)) {
printf("1 - %d \n", int_data);
}
mysql_stmt_close(stmt);
}
bool CMySqlDatabase::BlobReadDb( QString &strBlobFile, QString& strSql, QString& strError )
{
//http://www.cplusplus.com
QByteArray byData;
bool bRet = BlobReadDb( byData, strSql, strError );
if ( false == bRet ) {
return bRet;
}
QFile file( strBlobFile );
bRet = file.open( QIODevice::WriteOnly );
if ( !bRet ) {
return bRet;
}
file.write( byData );
file.close( );
return bRet;
#if false
MYSQL_BIND bind[ 1 ];
ulong length = 0;
QByteArray byteSql;
int nSize = 0;
const char* pSql = NULL;
char* bufData = NULL;
quint32 nData = 1024 * 1024 * 2;
int nRet = 0;
MYSQL_RES* res = NULL;
my_bool bGetMaxLen = 1;
hStmt = mysql_stmt_init( &hConnect );
bRet = ( NULL != hStmt );
if ( !bRet ) {
GetErrorMsg( 0, strError, false, strSql );
goto FileHandle;
}
byteSql = pCodec->fromUnicode( strSql );
nSize = byteSql.count( );
pSql = byteSql.data( );
bRet = ( 0 == mysql_stmt_prepare( hStmt, pSql, nSize ) );
if ( !bRet ){
GetErrorMsg( 0, strError, false, strSql );
goto StmtHandle;
}
bRet = ( 0 == mysql_stmt_execute( hStmt ) );
if ( !bRet ) {
GetErrorMsg( 0, strError, false, strSql );
goto StmtHandle;
}
// max_allowed_packet 16M
// write_timeout 120
// Net Buffer 16M
bufData = ( char* ) malloc( nData );
memset( bind, 0, sizeof ( bind ) );
bind[ 0 ].buffer_type = MYSQL_TYPE_LONG_BLOB;
bind[ 0 ].length = &length; // Return Real Data Length
bind[ 0 ].is_null = 0; /* Bind the buffers */
bind[ 0 ].buffer = bufData; // Bind data buffer
bind[ 0 ].buffer_length = nData; // Buffer Length
bRet = ( 0 == mysql_stmt_bind_result( hStmt, bind ) );
if ( !bRet ) {
GetErrorMsg( 0, strError, false, strSql );
goto NewHandle;
}
bRet = ( 0 == mysql_stmt_attr_set( hStmt, STMT_ATTR_UPDATE_MAX_LENGTH, &bGetMaxLen ) );
bRet = ( 0 == mysql_stmt_store_result( hStmt ) );
if ( !bRet ) {
GetErrorMsg( 0, strError, false, strSql );
goto NewHandle;
}
/////////////////////////////////// Get Meta Data
res = mysql_stmt_result_metadata( hStmt );
if ( NULL != res && 0 < res->field_count &&
nData < res->fields[ 0 ].max_length ) {
nData = res->fields[ 0 ].max_length; // Data Real Length
mysql_free_result( res );
bind[ 0 ].buffer_length = nData;
bufData = ( char* ) realloc( bufData, nData );
bind[ 0 ].buffer = bufData;
bRet = ( 0 == mysql_stmt_bind_result( hStmt, bind ) );
if ( !bRet ) {
GetErrorMsg( 0, strError, false, strSql );
goto NewHandle;
}
}
///////////////////////////////////
nRet = mysql_stmt_fetch( hStmt );
if ( MYSQL_DATA_TRUNCATED == nRet ) {
;
} else {
bRet = ( 0 == nRet );
if ( !bRet ) {
GetErrorMsg( 0, strError, false, strSql );
goto NewHandle;
}
}
file.write( ( const char* ) bufData, length );
NewHandle:
if ( NULL != bufData ) {
free( bufData );
}
bRet = ( 0 == mysql_stmt_free_result( hStmt ) );
if ( !bRet ) {
GetErrorMsg( 0, strError, false, strSql );
}
StmtHandle:
bRet = ( 0 == mysql_stmt_close( hStmt ) );
if ( !bRet ) {
GetErrorMsg( 0, strError, false, strSql );
}
FileHandle:
file.close( );
return bRet;
#endif
}
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;
}
int sqlite3_prepare(sqlite3* db, /* Database handle */
const char* zSql, /* SQL statement, UTF-8 encoded */
int nBytes, /* Maximum length of zSql in bytes. */
mysqlite3_stmt** ppStmt, /* OUT: Statement handle */
const char** pzTail /* OUT: Pointer to unused portion of zSql */
)
{
int rc = SQLITE_OK;
mysqlite3_stmt* stmt = (mysqlite3_stmt*)malloc(sizeof(mysqlite3_stmt));
stmt->mydb = db;
stmt->mystmt = mysql_stmt_init(db);
stmt->myres = NULL;
stmt->myparams = NULL;
stmt->results = NULL;
stmt->nresults = 0;
stmt->executed = 0;
stmt->nrow = 0;
stmt->lengths = NULL;
int stmt_len = statement_length(zSql, nBytes);
if (nBytes > 0 && nBytes < stmt_len)
{
stmt_len = nBytes;
}
// "Strip" trailing semicolon, if present
if (zSql[stmt_len-1] == ';')
{
stmt_len -= 1;
}
// Make a copy of the SQL and save it
stmt->sql = strndup(zSql, stmt_len);
mysql_stmt_prepare(stmt->mystmt, stmt->sql, stmt_len);
stmt->nparams = mysql_stmt_param_count(stmt->mystmt);
if (stmt->nparams > 0)
{
stmt->myparams = (MYSQL_BIND*)malloc(sizeof(MYSQL_BIND)*stmt->nparams);
}
/* Result set information */
stmt->myres = mysql_stmt_result_metadata(stmt->mystmt);
stmt->ncolumns = 0;
if (stmt->myres)
{
/* Get total columns in the query */
stmt->ncolumns = mysql_num_fields(stmt->myres);
// Set STMT_ATTR_UPDATE_MAX_LENGTH attribute
my_bool aBool = 1;
mysql_stmt_attr_set(stmt->mystmt, STMT_ATTR_UPDATE_MAX_LENGTH, &aBool);
if (stmt->ncolumns > 0)
{
stmt->results = malloc(sizeof(MYSQL_BIND)* stmt->ncolumns);
stmt->lengths = malloc(sizeof(unsigned long)* stmt->ncolumns);
memset(stmt->results, 0, sizeof(MYSQL_BIND)* stmt->ncolumns);
int i;
for (i=0; i < stmt->ncolumns; i++)
{
//stmt->results[i].buffer = malloc(stmt->myres->fields[i].max_length);
//stmt->results[i].buffer_type = stmt->myres->fields[i].type;
//stmt->results[i].buffer_length = stmt->myres->fields[i].max_length;
stmt->results[i].buffer = 0;
stmt->results[i].is_null = 0;
stmt->results[i].buffer_length = 0;
stmt->results[i].length = &stmt->lengths[i];
}
}
}
*ppStmt = (mysqlite3_stmt*)stmt;
if (pzTail)
{
(*pzTail) = NULL;
if (stmt_len < strlen(zSql))
{
(*pzTail) = zSql+stmt_len;
if (*pzTail[0] == ';') {
(*pzTail)++;
}
if (*pzTail[0] == '\0') {
*pzTail = NULL;
}
}
}
return rc;
};
