INSERT Mysql c++ api

**xoorus** · 29/07/2012, 14h59

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

Invité · 30/07/2012, 16h41

c'est normal que t'as
delete str[];
alors que bind.buffer= str; ?

**xoorus** · 30/07/2012, 16h51

j'ai enfin trouvé la réponse, il faut que je fasse un bind_result() avant de faire un mysql_stmt_store_result(), et que je fasse un mysql_bind_result.

Je vais poster la solution quand j'aurais fait du ménage dans mon code

**xoorus** · 30/07/2012, 22h10

je poste donc la solution, avec le contenu de mes fonctions.
En MySQL, il faut se servir des binds, même pour un SELECT, c'est de la que venait mon erreur

Je ne vous poste que le Execute() et le Sync(), car c'est d'ici que provenait mon erreur

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
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
 
void MySQLStatement::execute(ArchiveCollector & collector)
{
 
    MYSQL_FIELD *field_mysql;
	debug_log(debug_database, "execute %lx", (size_t)this);
	_ResultArchive result_archive(*this);
	int nbcolonnes = 0;
    bool is_a_select = static_cast < MySQLDatabase * > (database().get())->current_query_is_a_select();
    bool first_occur = true;// search column only once
 
	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);
    }
 
    if (is_a_select == true)
    {
        int count = 0;
        int nb_column = 0;
        unsigned long length;
        my_bool is_null;
        my_bool error;
        MYSQL_RES *res_set = mysql_stmt_result_metadata(_stmt);
 
        while(field_mysql = mysql_fetch_field(res_set)) // how many column
        {
            nb_column++;
        }
 
        _results_vectorbind.resize(nb_column);
        _lenght_selected_value.resize(nb_column);
        _error_selectedvalue.resize(nb_column);
        _is_null_selected_value.resize(nb_column);
 
        for (count = 0; count < nb_column ; count++)
        {
            _results_vectorbind[count].buffer_type= MYSQL_TYPE_STRING;
            _results_vectorbind[count].buffer_length= 0;
            _results_vectorbind[count].buffer= NULL;
            _results_vectorbind[count].is_null= &_is_null_selected_value[count];
            _results_vectorbind[count].length= &_lenght_selected_value[count];
            _results_vectorbind[count].error= &_error_selectedvalue[count];
        }
 
        mysql_stmt_bind_result(_stmt, &_results_vectorbind[0]);// vector will have selected values
 
        if (mysql_stmt_store_result(_stmt))
        {
          fprintf(stderr, " mysql_stmt_store_result() failed\n");
          fprintf(stderr, " %s\n", mysql_stmt_error(_stmt));
          exit(0);
        }
 
        /* Fetch all rows */
        int res_sql_fetch;
        res_sql_fetch = mysql_stmt_fetch(_stmt);
        while ( res_sql_fetch == 0 || res_sql_fetch == 101 ) //0 : succesfull - 101 if data is truncated (normal)
        {
            if (first_occur == true)
            {
                while(field_mysql = mysql_fetch_field(res_set)) // Nom de colonnes
                {
                    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);
            res_sql_fetch = mysql_stmt_fetch(_stmt);// fetch stmt again
        }
    }
 
    _reset();
}

On peut voir l'apparition des binds, et des vectors pour recuperer la valeur de ceux-ci après le mysql_stmt_bind_result()

Ici, la récupération des données :

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
 
 
	void sync(std::string & value, Field field, Group group, ArchiveFlags flags)
	{
        int num_column = _statement._tab_asso_nomcolonnes[field];
        MYSQL_BIND bind;
        my_bool is_null = 0;
        my_bool error = 0;
        long unsigned int lenght = 0;
        std::string string_left;
        char value_tmp[_statement._lenght_selected_value[num_column]];
        int position_last_char;
        int size_last_char;
 
        lenght = _statement._lenght_selected_value[num_column];
        bind.buffer_type= MYSQL_TYPE_STRING;
        bind.buffer= &value_tmp;
        bind.buffer_length= _statement._lenght_selected_value[num_column];
        bind.is_null= &is_null;
        bind.length= &lenght;
        bind.error= &error;
 
        int success;
        success = mysql_stmt_fetch_column(_statement.stmt(),&bind,num_column,0);
        value.assign(value_tmp,lenght);
	}

je récupère juste les valeurs contenues dans mes vector

En espérant aider au moins une personne qui plancherait sur ce problème :p

INSERT Mysql c++ api

C++

Discussions similaires

Partager

Partager