int dbrelay_mysql_colprec(void *db, int colnum)
{
mysql_db_t *mydb = (mysql_db_t *) db;
mydb->field = mysql_fetch_field_direct(mydb->result, colnum-1);
return mydb->field->max_length;
}
void dbrelay_mysql_coltype(void *db, int colnum, char *dest)
{
mysql_db_t *mydb = (mysql_db_t *) db;
mydb->field = mysql_fetch_field_direct(mydb->result, colnum-1);
dbrelay_mysql_get_sqltype_string(dest, mydb->field->type, mydb->field->length);
}
MysqlQuery::MysqlQuery(MYSQL_RES *query)
{
result=query;
if(result!=NULL)
{
row=mysql_fetch_row(result);
//获得结果集合的行数
m_nRows=mysql_num_rows(result);
m_nCols=mysql_num_fields(result);
mbEof=false;
//保存表头中的字段名
MYSQL_FIELD* field = NULL;
for (int i = 0; i < m_nCols; i++)
{
field = mysql_fetch_field_direct(result, i);
if (field && field->name)
{
m_fieldMap.insert(make_pair(field->name, i));
}
}
}
return;
}
void bindResults(MYSQL_RES *res)
{
init(mysql_num_fields(res));
for (int i = 0; i < columns; i++)
{
MYSQL_FIELD *col = mysql_fetch_field_direct(res, i);
switch (col->type)
{
case MYSQL_TYPE_DECIMAL:
case MYSQL_TYPE_NEWDECIMAL:
bindinfo[i].buffer_type = MYSQL_TYPE_STRING;
bindinfo[i].buffer_length = 100; // MORE - is there a better guess?
break;
case MYSQL_TYPE_TIMESTAMP:
case MYSQL_TYPE_DATETIME:
case MYSQL_TYPE_TIME:
case MYSQL_TYPE_DATE:
bindinfo[i].buffer_type = col->type;
bindinfo[i].buffer_length = sizeof(MYSQL_TIME);
break;
default:
bindinfo[i].buffer_type = col->type;
bindinfo[i].buffer_length = col->length;
break;
}
bindinfo[i].buffer = rtlMalloc(bindinfo[i].buffer_length);
}
}
static VALUE rb_mysql_result_fetch_field(VALUE self, unsigned int idx, int symbolize_keys) {
VALUE rb_field;
GET_RESULT(self);
if (wrapper->fields == Qnil) {
wrapper->numberOfFields = mysql_num_fields(wrapper->result);
wrapper->fields = rb_ary_new2(wrapper->numberOfFields);
}
rb_field = rb_ary_entry(wrapper->fields, idx);
if (rb_field == Qnil) {
MYSQL_FIELD *field = NULL;
rb_encoding *default_internal_enc = rb_default_internal_encoding();
rb_encoding *conn_enc = rb_to_encoding(wrapper->encoding);
field = mysql_fetch_field_direct(wrapper->result, idx);
if (symbolize_keys) {
rb_field = rb_intern3(field->name, field->name_length, rb_utf8_encoding());
rb_field = ID2SYM(rb_field);
} else {
rb_field = rb_str_new(field->name, field->name_length);
rb_enc_associate(rb_field, conn_enc);
if (default_internal_enc) {
rb_field = rb_str_export_to_enc(rb_field, default_internal_enc);
}
}
rb_ary_store(wrapper->fields, idx, rb_field);
}
return rb_field;
}
void dump_file()
{
MYSQL mysql;
if (!mysql_init(&mysql))
return;
if (!mysql_real_connect(&mysql, CONN_HOST , CONN_USER , CONN_PASS, NULL , MYSQL_PORT, NULL, 0))
return;
if (mysql_select_db(&mysql, CONN_DB))
return;
char *sqlstr = "SELECT img_name img_metadata FROM image";
if (mysql_query(&mysql, sqlstr))
return;
MYSQL_RES *res;
if (!(res = mysql_use_result(&mysql)))
return;
printf("Writing to wiki-images/.\n");
unsigned int num_fields;
num_fields = mysql_num_fields(res);
unsigned int i;
MYSQL_FIELD *fields;
MYSQL_ROW row;
while((row = mysql_fetch_row(res))) {
for (i=0 ; i < num_fields; i++) {
fields = mysql_fetch_field_direct(res, i);
}
}
mysql_free_result(res);
mysql_close(&mysql);
}
T MysqlResultSet_new(void *stmt, int maxRows, int keep) {
T R;
assert(stmt);
NEW(R);
R->stmt = stmt;
R->keep = keep;
R->maxRows = maxRows;
R->columnCount = mysql_stmt_field_count(R->stmt);
if ((R->columnCount <= 0) || ! (R->meta = mysql_stmt_result_metadata(R->stmt))) {
DEBUG("Warning: column error - %s\n", mysql_stmt_error(stmt));
R->stop = true;
} else {
R->bind = CALLOC(R->columnCount, sizeof (MYSQL_BIND));
R->columns = CALLOC(R->columnCount, sizeof (struct column_t));
for (int i = 0; i < R->columnCount; i++) {
R->columns[i].buffer = ALLOC(STRLEN + 1);
R->bind[i].buffer_type = MYSQL_TYPE_STRING;
R->bind[i].buffer = R->columns[i].buffer;
R->bind[i].buffer_length = STRLEN;
R->bind[i].is_null = &R->columns[i].is_null;
R->bind[i].length = &R->columns[i].real_length;
R->columns[i].field = mysql_fetch_field_direct(R->meta, i);
}
if ((R->lastError = mysql_stmt_bind_result(R->stmt, R->bind))) {
DEBUG("Warning: bind error - %s\n", mysql_stmt_error(stmt));
R->stop = true;
}
}
return R;
}
char *dbrelay_mysql_colname(void *db, int colnum)
{
mysql_db_t *mydb = (mysql_db_t *) db;
mydb->field = mysql_fetch_field_direct(mydb->result, colnum-1);
return mydb->field->name;
}
int dbrelay_mysql_colscale(void *db, int colnum)
{
mysql_db_t *mydb = (mysql_db_t *) db;
mydb->field = mysql_fetch_field_direct(mydb->result, colnum-1);
return mydb->field->decimals;
}
static JSVAL fetch_field_direct(JSARGS args) {
HandleScope scope;
MYSQL_RES *res = (MYSQL_RES *) args[0]->IntegerValue();
MYSQL_FIELD *f = mysql_fetch_field_direct(res, args[1]->IntegerValue());
JSOBJ o = Object::New();
MakeField(f, o);
return scope.Close(o);
}
CharString DatabaseMYSQL::field(QueryHandle hQuery, int f ) const
{
QueryResult * pQuery = (QueryResult *)hQuery;
if ( pQuery == NULL || pQuery->pResult == NULL )
return "";
MYSQL_FIELD * pField = mysql_fetch_field_direct( pQuery->pResult, f );
return pField != NULL ? CharString( pField->name ) : "";
}
/* fetch_field_direct(nr) */
static VALUE fetch_field_direct(VALUE obj, VALUE nr)
{
MYSQL_RES* res;
unsigned int max;
unsigned int n;
check_free(obj);
res = GetMysqlRes(obj);
max = mysql_num_fields(res);
n = NUM2INT(nr);
if (n >= max)
rb_raise(eMysql, "%d: out of range (max: %d)", n, max-1);
#if MYSQL_VERSION_ID >= 32226
return make_field_obj(mysql_fetch_field_direct(res, n));
#else
return make_field_obj(&mysql_fetch_field_direct(res, n));
#endif
}
sql_field_c sql_result_c::fetch_field( unsigned int field_idx )
{
if ( query && res )
{
MYSQL_FIELD *field = mysql_fetch_field_direct( res, field_idx );
return sql_field_c( field );
}
return sql_field_c();
}
// >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
int MySQLDatabase::findColumn(const char* name) {
MYSQL_FIELD* field;
for ( int i = 0; i < _fieldCount; ++i ) {
field = mysql_fetch_field_direct(_result, i);
if ( !strcmp(field->name, name) )
return i;
}
return -1;
}
DBType MyBoundResults::GetFieldType(unsigned int field)
{
if (field >= m_ColCount)
{
return DBType_Unknown;
}
MYSQL_FIELD *fld = mysql_fetch_field_direct(m_pRes, field);
return GetOurType(fld->type);
}
const char *MyBasicResults::FieldNumToName(unsigned int colId)
{
if (colId >= GetFieldCount())
{
return NULL;
}
MYSQL_FIELD *field = mysql_fetch_field_direct(m_pRes, colId);
return field ? (field->name ? field->name : "") : "";
}
const char *MyBoundResults::FieldNumToName(unsigned int columnId)
{
if (columnId >= m_ColCount)
{
return NULL;
}
MYSQL_FIELD *field = mysql_fetch_field_direct(m_pRes, columnId);
return field ? (field->name ? field->name : "") : "";
}
bool MyBoundResults::Initialize()
{
/* Check if we need to build our result binding information */
if (!m_Initialized)
{
for (unsigned int i = 0; i < m_ColCount; i++)
{
MYSQL_FIELD *field = mysql_fetch_field_direct(m_pRes, i);
DBType type = GetOurType(field->type);
m_bind[i].length = &(m_pull[i].my_length);
m_bind[i].is_null = &(m_pull[i].my_null);
if (type == DBType_Integer)
{
m_bind[i].buffer_type = MYSQL_TYPE_LONG;
m_bind[i].buffer = &(m_pull[i].data.ival);
}
else if (type == DBType_Float) {
m_bind[i].buffer_type = MYSQL_TYPE_FLOAT;
m_bind[i].buffer = &(m_pull[i].data.ival);
}
else if (type == DBType_String || type == DBType_Blob) {
m_bind[i].buffer_type = GetTheirType(type);
/* We bound this to 2048 bytes. Otherwise a MEDIUMBLOB
* or something could allocate horrible amounts of memory
* because MySQL is incompetent.
*/
size_t creat_length = (size_t)field->length;
if (!creat_length || creat_length > DEFAULT_BUFFER_SIZE)
{
creat_length = DEFAULT_BUFFER_SIZE;
}
m_pull[i].blob = new unsigned char[creat_length];
m_pull[i].length = creat_length;
m_bind[i].buffer = m_pull[i].blob;
m_bind[i].buffer_length = (unsigned long)creat_length;
}
else {
return false;
}
}
m_Initialized = true;
}
/* Do the actual bind */
return (mysql_stmt_bind_result(m_stmt, m_bind) == 0);
}
void print_fields (MYSQL_RES *result)
{
unsigned int num_fields;
unsigned int i;
MYSQL_FIELD *field;
num_fields = mysql_num_fields(result);
for(i = 0; i < num_fields; i++)
{
field = mysql_fetch_field_direct(result, i);
fprintf(logfile, "%s[%u] ", field->name, i);
}
fprintf (logfile, "\n");
}
void Statement::Execute() {
if (! _db.IsConnected()) {
throw DatabaseException("Error in Statement::Execute", 0, "----", "Database is not connected");
}
_numberAffectedRows = 0;
_eof = true;
_currentColumn = 0;
if (ParameterCount() != _params.size()) {
throw DatabaseException("Error in Statement::Execute", 0, "----", "Have not yet assigned all parameters");
}
if (mysql_stmt_bind_param(_stmt, _bind) != 0) {
throw DatabaseException(_stmt, "Error in Statement::Execute while binding parameters");
}
if (mysql_stmt_execute(_stmt) != 0) {
throw DatabaseException(_stmt, "Error in Statement::Execute while executing statement");
}
if (_numberResultColumns > 0) {
if (mysql_stmt_store_result(_stmt) != 0) {
throw DatabaseException(_stmt, "Error in Statement::Execute while storing results");
}
_eof = false;
}
else {
_numberAffectedRows = mysql_stmt_affected_rows(_stmt);
}
_resultWasStored = true;
if (_hasBlobField && _resultBind != NULL) {
MYSQL_RES *res = mysql_stmt_result_metadata(_stmt);
if (res != NULL) {
for (unsigned int i = 0; i < _resultParams.size(); i++) {
MYSQL_FIELD *column = mysql_fetch_field_direct(res, i);
if (_resultBind[i].buffer_type == MYSQL_TYPE_BLOB) {
_resultParams[i]->ResizeBlob(column->max_length);
_resultBind[i].buffer = _resultParams[i]->Buffer();
_resultBind[i].buffer_length = _resultParams[i]->BufferSize();
_resultBind[i].length = _resultParams[i]->BufferLength();
}
}
mysql_free_result(res);
}
}
}
int main(void)
{
MYSQL *mysql;
MYSQL *mysqlr;
MYSQL_RES *results;
MYSQL_ROW record;
mysql = mysql_init(NULL);
unsigned int num = 0;
int i = 0;
MYSQL_FIELD *field;
char sql[100] = "select * from fixtable limit 10";
mysqlr = mysql_real_connect(mysql, "127.0.0.1","root","1", "test", 3306,NULL,0);
if(mysqlr == NULL) {
printf("error\r\n");
printf("mysql_real_connect failed: %s\r\n", mysql_error(mysql));
exit(1);
}
while(1) {
mysql_query(mysql, sql);
results = mysql_store_result(mysql);
num = mysql_num_fields(results);
for(i=0;i<num;i++) {
field = mysql_fetch_field_direct(results, i);
printf("%10s|", field->name);
}
printf("\r\n");
while((record = mysql_fetch_row(results))) {
for(i=0;i<num;i++) {
printf("%10s|", record[i]);
}
printf("\r\n---------------------------------------------------------------------\r\n");
}
printf("SQL: %s \r\n", sql);
printf("\r\nsql>");
fgets(sql, 100, stdin);
}
mysql_free_result(results);
mysql_close(mysql);
mysql_server_end();
return 0;
}
static VALUE rb_mysql_result_fetch_field(VALUE self, unsigned int idx, short int symbolize_keys) {
mysql2_result_wrapper * wrapper;
VALUE rb_field;
GetMysql2Result(self, wrapper);
if (wrapper->fields == Qnil) {
wrapper->numberOfFields = mysql_num_fields(wrapper->result);
wrapper->fields = rb_ary_new2(wrapper->numberOfFields);
}
rb_field = rb_ary_entry(wrapper->fields, idx);
if (rb_field == Qnil) {
MYSQL_FIELD *field = NULL;
#ifdef HAVE_RUBY_ENCODING_H
rb_encoding *default_internal_enc = rb_default_internal_encoding();
rb_encoding *conn_enc = rb_to_encoding(wrapper->encoding);
#endif
field = mysql_fetch_field_direct(wrapper->result, idx);
if (symbolize_keys) {
char buf[field->name_length+1];
memcpy(buf, field->name, field->name_length);
buf[field->name_length] = 0;
#ifdef HAVE_RB_INTERN3
rb_field = rb_intern3(buf, field->name_length, rb_utf8_encoding());
rb_field = ID2SYM(rb_field);
#else
VALUE colStr;
colStr = rb_str_new2(buf);
rb_field = ID2SYM(rb_to_id(colStr));
#endif
} else {
rb_field = rb_str_new(field->name, field->name_length);
#ifdef HAVE_RUBY_ENCODING_H
rb_enc_associate(rb_field, conn_enc);
if (default_internal_enc) {
rb_field = rb_str_export_to_enc(rb_field, default_internal_enc);
}
#endif
}
rb_ary_store(wrapper->fields, idx, rb_field);
}
return rb_field;
}
/// Reports debug information about a truncated column.
///
/// @private
static void SqlStmt_P_ShowDebugTruncatedColumn(SqlStmt* self, size_t i)
{
MYSQL_RES* meta;
MYSQL_FIELD* field;
MYSQL_BIND* column;
meta = mysql_stmt_result_metadata(self->stmt);
field = mysql_fetch_field_direct(meta, (unsigned int)i);
ShowSQL("DB error - data of field '%s' was truncated.\n", field->name);
ShowDebug("column - %lu\n", (unsigned long)i);
Sql_P_ShowDebugMysqlFieldInfo("data - ", field->type, field->flags&UNSIGNED_FLAG, self->column_lengths[i].length, "");
column = &self->columns[i];
if( column->buffer_type == MYSQL_TYPE_STRING )
Sql_P_ShowDebugMysqlFieldInfo("buffer - ", column->buffer_type, column->is_unsigned, column->buffer_length, "+1(nul-terminator)");
else
Sql_P_ShowDebugMysqlFieldInfo("buffer - ", column->buffer_type, column->is_unsigned, column->buffer_length, "");
mysql_free_result(meta);
}
bool wxMySQLResult::GetFieldInfo(wxMySQLField * field, unsigned int fieldnum)
{
if(GetFieldCount() <= fieldnum) return false;
MYSQL_FIELD * fld = mysql_fetch_field_direct(m_Res, fieldnum);
if(!fld || !field) return false;
field->m_Name = fld->name;
field->m_NameOrg = fld->org_name;
field->m_TableName = fld->table;
field->m_TableNameOrg = fld->org_table;
field->m_DBName = fld->db;
field->m_DBCatalog = fld->catalog;
field->m_DefaultValue = fld->def;
field->m_Length = fld->length;
field->m_MaxLength = fld->max_length;
field->m_Decimals = fld->decimals;
field->m_FieldType = (wxMySQLFieldType)fld->type;
field->m_Flags = fld->flags;
return true;
}
int MysqlResult::FieldInfo(int idx, char *field_name, int name_len,
enum_field_types *field_type)
{
if(m_pResult == NULL)
{
snprintf(m_errMsg, sizeof(m_errMsg), "no result");
return -1;
}
int iMax = mysql_num_fields(m_pResult);
if(idx < 0 || idx >= iMax)
{
snprintf(m_errMsg, sizeof(m_errMsg), "idx = %d not in [0, %d)", idx, iMax);
return -1;
}
MYSQL_FIELD *p = mysql_fetch_field_direct(m_pResult, idx);
snprintf(field_name, name_len, "%s", p->name);
*field_type = p->type;
return 0;
}
int main(void)
{
// int msi = mysql_server_init(num_elements, server_options, server_groups);
// printf("mysql_server_init: %d \r\n", msi);
mysql = mysql_init(NULL);
// mysql_options(mysql, MYSQL_READ_DEFAULT_GROUP, "libmysqld_client");
// mysql_options(mysql, MYSQL_OPT_USE_EMBEDDED_CONNECTION, NULL);
unsigned int num = 0;
int i = 0;
MYSQL_FIELD *field;
mysqlr = mysql_real_connect(mysql, "127.0.0.1","root","111111", "stone", 3306,NULL,0);
if(mysqlr == NULL) {
printf("error\r\n");
printf("mysql_real_connect failed: %s\r\n", mysql_error(mysql));
exit(1);
}
mysql_query(mysql, "select * from fixtable limit 10");
results = mysql_store_result(mysql);
num = mysql_num_fields(results);
for(i=0;i<num;i++) {
field = mysql_fetch_field_direct(results, i);
printf("%s |", field->name);
}
printf("\r\n");
while((record = mysql_fetch_row(results))) {
for(i=0;i<num;i++) {
printf("%s |", record[i]);
}
printf("\r\n----------------------\r\n");
}
mysql_free_result(results);
mysql_close(mysql);
mysql_server_end();
return 0;
}
int dbrelay_mysql_is_quoted(void *db, int colnum)
{
mysql_db_t *mydb = (mysql_db_t *) db;
mydb->field = mysql_fetch_field_direct(mydb->result, colnum-1);
int coltype = mydb->field->type;
if (coltype == MYSQL_TYPE_VARCHAR ||
coltype == MYSQL_TYPE_VAR_STRING ||
coltype == MYSQL_TYPE_DATE ||
coltype == MYSQL_TYPE_TIME ||
coltype == MYSQL_TYPE_DATETIME ||
coltype == MYSQL_TYPE_BLOB ||
coltype == MYSQL_TYPE_STRING ||
coltype == MYSQL_TYPE_LONG_BLOB ||
coltype == MYSQL_TYPE_TINY_BLOB ||
coltype == MYSQL_TYPE_NEWDATE ||
coltype == MYSQL_TYPE_MEDIUM_BLOB)
return 1;
else return 0;
}
bool embeddedResult::reset (const QString& query)
{
if (!driver() || !driver()->isOpen() || driver()->isOpenError() || !d->driver)
return false;
d->preparedQuery = false;
cleanup();
//qDebug() << "In reset: " + query;
const QByteArray encQuery(fromUnicode(d->driver->d->tc, query));
//const QByteArray encQuery = query.toLocal8Bit();
if (mysql_real_query(d->driver->d->mysql, encQuery.data(), encQuery.length())) {
setLastError(qMakeError(QCoreApplication::translate("embeddedResult", "Unable to execute query"),
QSqlError::StatementError, d->driver->d));
return false;
}
d->result = mysql_store_result(d->driver->d->mysql);
if (!d->result && mysql_field_count(d->driver->d->mysql) > 0) {
setLastError(qMakeError(QCoreApplication::translate("embeddedResult", "Unable to store result"),
QSqlError::StatementError, d->driver->d));
return false;
}
int numFields = mysql_field_count(d->driver->d->mysql);
setSelect(numFields != 0);
d->fields.resize(numFields);
d->rowsAffected = mysql_affected_rows(d->driver->d->mysql);
if (isSelect()) {
for(int i = 0; i < numFields; i++) {
MYSQL_FIELD* field = mysql_fetch_field_direct(d->result, i);
d->fields[i].type = qDecodeMYSQLType(field->type, field->flags);
}
setAt(QSql::BeforeFirstRow);
}
setActive(true);
return isActive();
}
bool QMYSQLResult::reset ( const QString& query )
{
if ( !driver() )
return FALSE;
if ( !driver()-> isOpen() || driver()->isOpenError() )
return FALSE;
cleanup();
const char *encQuery = query.ascii();
if ( mysql_real_query( d->mysql, encQuery, qstrlen(encQuery) ) ) {
setLastError( qMakeError("Unable to execute query", QSqlError::Statement, d ) );
return FALSE;
}
if ( isForwardOnly() ) {
if ( isActive() || isValid() ) // have to empty the results from previous query
fetchLast();
d->result = mysql_use_result( d->mysql );
} else {
d->result = mysql_store_result( d->mysql );
}
if ( !d->result && mysql_field_count( d->mysql ) > 0 ) {
setLastError( qMakeError( "Unable to store result", QSqlError::Statement, d ) );
return FALSE;
}
int numFields = mysql_field_count( d->mysql );
setSelect( !( numFields == 0) );
d->fieldTypes.resize( numFields );
if ( isSelect() ) {
for( int i = 0; i < numFields; i++) {
MYSQL_FIELD* field = mysql_fetch_field_direct( d->result, i );
if ( field->type == FIELD_TYPE_DECIMAL )
d->fieldTypes[i] = QVariant::String;
else
d->fieldTypes[i] = qDecodeMYSQLType( field->type, field->flags );
}
}
setActive( TRUE );
return TRUE;
}
SqlResult::SqlResult(MYSQL *h) :
handle_(h),
result_(mysql_store_result(handle_)),
currentRow_(0),
numRows_(0),
fields_(),
errorCode_(mysql_errno(handle_)),
errorText_(mysql_error(handle_))
{
//DEBUG("SqlResult()");
if (result_) {
unsigned fieldCount = mysql_num_fields(result_);
fields_.reserve(fieldCount);
data_.resize(fieldCount);
numRows_ = mysql_num_rows(result_);
for (unsigned i = 0; i != fieldCount; ++i) {
fields_.push_back(mysql_fetch_field_direct(result_, i));
}
}
}
