Bonjour à tous, je commence un peu à devenir fou en ce moment précis!

Je bataille sur un problème qui à l'air si simple ...

Je dois tout simplement récupérer des valeurs dans ma BDD, le problème étant que le nombre de résultats est bien retourné, mais que je n'ai que des valeurs nulles..

Je m'excuse d'avance pour le code qui est assez long, je le commente et le raccourcis au maximum

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
RetainPtr< Statement > MySQLDatabase::prepare(const std::string & sql)
{
// sql = SELECT title FROM test WHERE WHERE title LIKE '%d'
// doit me retourner les valeurs Second ou Third
 
	MYSQL_STMT * stmt;
    _current_query_is_a_select = false;
 
	stmt = mysql_stmt_init(&_handle);
	if (!stmt)
    {
        fprintf(stderr, " mysql_stmt_init(), out of memory\n");
        exit(0);
    }
 
    if (sql.find("SELECT") != -1)
    {
      _current_query_is_a_select = true;
    }
 
    if (mysql_stmt_prepare(stmt, sql.c_str(), sql.size()) != 0)
    {
        //error
        aranatha_log("query: %s", sql.c_str());
        handle_error(mysql_stmt_prepare(stmt, sql.c_str(), sql.size()));
    }
 
	debug_log(debug_database, "query %lx: %s", (size_t)statement.get(), sql.c_str());
}
ceci est ce qui me sert à préparer les requêtes

suit ce qui me sert a exécuter ma requête et a traiter mes résultats.
Ne faites pas attention aux variables statement qui changent, je ne suis pas dans la même classe.

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
   MYSQL_ROW row;
    MYSQL_FIELD *field_mysql;
    MYSQL_RES *result;
    std::string data;
	debug_log(debug_database, "execute %lx", (size_t)this);
	_ResultArchive result_archive(*this);
	int numres;
	int nbcolonnes = 0;
    bool is_a_select = static_cast < MySQLDatabase * > (database().get())->current_query_is_a_select();
 
	if (!_stmt)
    {
      fprintf(stderr, " mysql_stmt_init(), out of memory\n");
      exit(0);
    }
 
    if(mysql_stmt_execute(_stmt) != 0)
    {
        //error
        fprintf(stderr, " mysql_stmt_execute(), 1 failed\n");
        fprintf(stderr, " %s\n", mysql_stmt_error(_stmt),"\n");
        exit(0);
    }
 
    bool first_occur = true;
    mysql_stmt_store_result(_stmt);
 
    while(!mysql_stmt_fetch(_stmt))// fonctionne, j'ai autant d'occurences de boucle que de résultats attendus
    {
        if (first_occur == true)
        {
             MYSQL_RES *n = mysql_stmt_result_metadata(_stmt);
            while(field_mysql = mysql_fetch_field(n)) // Nom de colonnes
            {
                numres = mysql_num_rows(n);
                boost::optional < Field > field_name;
                field_name = field_for_name(field_mysql->name);
                if (field_name != NULL)
                {
                    // initialised
                    _tab_asso_nomcolonnes[*field_name] = nbcolonnes; // *field_name is no longer a boost::optionnal <Field> but a Field
                    nbcolonnes++;
                }
            }
            first_occur = false;
        }
        collector.collect(result_archive);// collecte les resultats
    };
et le dernier bout sert à récupérer les données retournées :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
 
void collect(Archive & archive)
	{
		std::string name;
		archive.sync(name, field_title, group_title, 0);// doit retourner second ou third, mais retourne toujours un NULL
        	assert(name == "second" || name == "third"); 
		++result_count;
	}
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
void sync(std::string & value, Field field, Group group, ArchiveFlags flags)
	{
	    if (value.capacity() < 0)
            value.resize(63);
        else
            value.resize(value.capacity());
 
        MYSQL_BIND bind;
        my_bool is_null = 0;
        unsigned long length = 0;
        my_bool error = 0;
        std::string string_left;
        int position_last_char;
        int size_last_char;
 
        char* str = new char[value.size()+1];
        strcpy(str, value.c_str());
        // utilisation de str
        delete[] str;
 
        /* STRING COLUMN */
        bind.buffer_type= MYSQL_TYPE_STRING;
        bind.buffer= str;
        bind.buffer_length= value.size();
        bind.is_null= &is_null;
        bind.length= &length;
        bind.error= &error;
 
        position_last_char = value.size();
 
        size_t sd;
        int success;
 
        sd = _statement._tab_asso_nomcolonnes[field];
        success = mysql_stmt_fetch_column(_statement.stmt(),&bind,_statement._tab_asso_nomcolonnes[field],0);
	}
voila, je suis désolé pour le paquet, mais je suis vraiment perdu la ><

Je vous remercie pour toutes les pistes que vous pouvez me donner