Insertion données avec caractères accentués dans DB MySQL

Version imprimable

21/04/2021, 01h16
Portocolo951

Insertion données avec caractères accentués dans DB MySQL

Bonsoir !

J'essaie d'insérer une ligne d'enregistrement dans une base de données MySQL 5.7 via un programme écrit en C.

Dans ce programme écrit en C, je demande à l'utilisateur d'entrer les différentes données de l'enregistrement.

La requête se construit et doit être envoyée à la DB via l'API MySQL.

Mais j'ai beau avoir essayé plusieurs solutions pour résoudre l'insertion de données avec caractères accentués, je n'y arrive vraiment pas.

Il y a à chaque fois une erreur, quelle que soit la solution utilisée...

Sous Linux, il n'y a pas ce souci. Tout fonctionne très bien avec des chars.

Par contre, sous Windows, c'est une tout autre histoire... C'est sous cet OS que le problème se pose.

J'utilise Visual Studio Community.

Avez-vous une solution viable à me proposer ?

Merci à tous !
21/04/2021, 02h17
foetus
Il faut + de précisions :zoubi:

Mais si tu utilises les lignes de commandes, sous Windows et Linux, l'encodage est différent. Respectivement "codepage" OEM et UTF-8
Quoique depuis Windows 10 version 1803, Windows permet de choisir l'UTF-8 pour remplacer l'ANSI/ les "codepages" OEM.

Ensuite, cela va dépendre également :mrgreen: :
- du type de caractères que tu vas utiliser en C : char pour l'ASCI, unsigned char pour l'UTF-8, wchar_t pour l'UTF-16. Voire des types spécifiques imposés par 1 bibliothèque
- l'encodage de ta base de données/ de ta table. Peut-être également la collation.
21/04/2021, 13h53
Portocolo951
Effectivement, je suis en ligne de commande :)

J'ai déjà utilisé wchar_t dans d'autres programmes en C.

Du coup, j'ai tout passé en wchar_t (et j'ai adapté les fonctions à utiliser en conséquence).

Il y a 2 problèmes maintenant :
- Ma fonction qui vérifie s'il y a une quote dans chacune de mes données et qui l'échappe semble provoquer une corruption du HEAP lorsque je fais le free de mes données à la fin de mon main.
- Si je désactive momentanément l'utilisation de cette fonction, les caractères accentués ne s'affichent pas correctement dans la base de données (je vois un ? dans un carré à la place du caractère accentué).
Ma base de données et mes tables sont en UTF-8.

J'utilise la fonction wcstombs pour convertir ma requête wchar_t UTF-16 en une requête char UTF-8 car la fonction mysql_query demande une requête en const char * en paramètre.

Voici les 3 fichiers de mon code :
https://pastebin.com/D42ArnNu
https://pastebin.com/Z8WxjUHS
https://pastebin.com/1XCgcmpK

Ma DB de test :
https://pastebin.com/y1UPcFvg
21/04/2021, 14h33
Portocolo951

Pour le HEAP corrompu, je pense avoir résolu ce problème-là.

Dans le 2ème fichier de code (https://pastebin.com/9D7XrBEY - aux lignes 31, 81 et 111), j'ai modifié pour faire un sizeof(wchar_t) * ce qu'il y a déjà pour le 2ème paramètre pour mes mallocs/reallocs.

Ce problème-là semble résolu.

Il reste le problème des caractères accentués à résoudre.
21/04/2021, 17h50
foetus
Je n'ai fait que lire mais ton code est spécifique :mrgreen:
- pas besoin de return à la toute fin pour les procédures (fonction qui retourne void)
- pas besoin de parenthèser les retours (comme return (EXIT_SUCCESS);)
- tu peux utiliser le pointeur pour changer les caractères, au lieu d'utiliser la syntaxe tableau
- il me semble que tu as la fonction wprintf
Et ensuite de ce que j'ai vu :mrgreen:
- ton code qui gère les problèmes d'allocation ne quitte pas la fonction. Donc si tu as 1 allocation NULL, ta fonction continue et cela doit crasher.
- tu oublies d'ajouter le caractères sentinelle '\0' dans ta fonction DemandeChaineCaracteres. Tes corruptions peuvent venir de là : les fonctions basées sur le caractère '\0' débordent.
- realloc se comporte comme 1 malloc si ta variable est NULL (<- la première fois en gros)
- Dans ta fonction VerifierEtAjouterQuote, tu alloues 1 chaîne de caractères de char puisque tu ne précises pas le sizeof (*)
- Dans ta fonction VerifierEtAjouterQuote, pour compter le nombre de quotes, tu devrais t'arrêter au caractère '\0'.
- À vérifier : mais tu testes des wchar_t avec de simples char ('\'', '\0' par exemple), techniquement cela peut foirer
* : D'après ce que tu écris, cela veut dire que tes caractères accentués sont reconnus lorsqu'ils sont castés en char :weird: :koi:

Bonjour

Il faut faire attention au realloc car si le realloc ne se passe pas, tu perds le pointeur de départ (qui avait lui été alloué et que tu ne peux désormais plus libérer)

En fait, au lieu d'écrire pt=realloc(pt, ...) il te faut écrire tmp=realloc(pt, ...) puis, si realloc a réussi, écrire alors pt=tmp.
Je ne vois pas trop l'utilité d'écrire une fonction void à laquelle on passe l'adresse du pointeur qui sera alloué. Je verrais mieux une fonction qui ne reçoit rien et qui alloue le pointeur, le remplit et renvoie le pointeur alloué. Déjà tu t'embêtes plus avec cette double indirection.
Et il faut aussi penser à ce qui se passe si le buffer ne contient rien => dans ce cas, renvoyer une chaine vide

Bref voilà comment j'écrirais cette fonction
Code:

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 wchar_t *DemandeChaineCaracteres() { // Déclaration de variable(s) size_t dAlloc=0; size_t dPosition=0 wchar_t *pChaine=NULL; wchar_t cCaract; wchar_t *pt; // Pour être sûr d'allouer ne serait-ce qu'une chaine vide while (1) { // Si on a atteint la taille maximale de la chaine de caractères (ce qui arrive la première fois quand dPosition=dAlloc=0) if (dPosition == dAlloc) { // on réalloue dynamiquement pour l'augmenter (si pChaine=NULL le realloc se comporte comme malloc) dAlloc+=50; // On peut mettre ce 50 en macro plutôt qu'en variable, ça évite de bouffer de la RAM pour que dalle (on dirait que tu bosses chez Micro$oft)... wchar_t *tmp=realloc(pChaine, sizeof(*tmp)*dAlloc); if (tmp == NULL) { free(pChaine); // Fonctionne même si pChaine est à NULL AfficherMessageQuandReallocationNotOkChaineCaracteres(); // Lui il pourrait être sorti de cette fonction pour être mis dans la fonction appelante return NULL; } pChaine=tmp; // On place/replace le pointeur à la position de la nouvelle chaine pt=pChaine + dPosition; } // Lecture buffer cCaract=getwchar(); // Si on a fini, on sort de la boucle (le '\0' sera mis à la fin) if (cCaract == '\n' || cCaract == 0) break; // On insère le caractère lu à la bonne position // On avance d'une position *pt=cCaract; dPostion++; pt++; } // La fin de la chaine *pt='\0'; return pChaine; }
Comme ça, l'appelant, au lieu d'écrire wchar_t *pChaine; DemandeChaineCaracteres(&pChaine) il écrit plus simplement wchar_t *pChaine=DemandeChaineCaracteres().

Après tests, on peut mettre L devant 1 chaîne de caractères, mais aussi devant 1 caractère (pour spécifier que c'est de l'UTF-16)
Donc, comme je l'ai mentionné, je pense qu'on devrait utiliser (même dans le code de @Sve@r) les caractères L'\0', L'\'', L'\n' par exemple.
Mais je ne sais pas si cela change quelque chose :koi:

Et pour ton histoire d'échappement, cela fonctionne nickel, je ne comprends pas d'où cela peut provenir :koi:
1 code avec quelques tests succincts. Attention : on ne peut pas mixer printf et wprintf. C'est soit l'1 soit l'autre :aie:

Code:

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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
#include <stdio.h>
#include <stdlib.h>
#include <wchar.h>
 
 
/*****************************************************************************/
/***********************************  Main  **********************************/
/*****************************************************************************/
 
void UTF_16_display_hexa(wchar_t* str, char* end_str) {
    if (str != NULL) {
        size_t len = wcslen(str);
 
        if (len > 0) {
            size_t c;
            wchar_t* str_c;
            unsigned char bit_hi, bit_lo;
 
            for(c=1, str_c=str; c <= len; ++c, ++str_c) {
                bit_hi = (((*str_c) >> 8) & 0xFF);
                bit_lo = ((*str_c) & 0xFF);
 
                printf("%02X%02X%c", bit_hi, bit_lo, (((c % 8) != 0)? ' ': '\n'));
            }
        }
 
        if (end_str != NULL) { printf("%s", end_str); }
    }
}
 
 
wchar_t* UTF_16_escape(wchar_t* str) {
    wchar_t* escape_str;
 
    if (str != NULL) {
        size_t len, nb_quotes;
        wchar_t* str_c;
 
//      Calculate len and nb_quotes
        str_c = str;
 
        len       = 0;
        nb_quotes = 0;
 
        while ((*str_c) != L'\0') {
            if ((*str_c) == L'\'') { ++nb_quotes; }
 
            ++str_c;
            ++len;
        }
 
        printf("UTF_16_escape - debug: len : %lu, nb_quotes : %lu\n", len, nb_quotes);
//      wprintf(L"UTF_16_escape - debug: len : %lu, nb_quotes : %lu\n", len, nb_quotes);
 
        if (len > 0) {
//          Allocate and copy/ escape
            escape_str = malloc(sizeof(wchar_t) * (len + nb_quotes + 1));
 
            if (escape_str != NULL) {
                if (nb_quotes > 0) {
                    wchar_t* escape_str_c;
 
                    str_c        = str;
                    escape_str_c = escape_str;
 
                    len = 0;
 
                    while ((*str_c) != L'\0') {
                        if ((*str_c) == L'\'') {
                            (*escape_str_c) = L'\\';
                            ++escape_str_c;
                        }
 
                        (*escape_str_c) = (*str_c);
 
                        ++str_c;
                        ++escape_str_c;
                        ++len;
                    }
                } else {
                    wcscpy(escape_str, str);
                }
 
                escape_str[(len + nb_quotes)] = L'\0';
            }
        } else {
            escape_str = NULL;
        }
    } else {
        escape_str = NULL;
    }
 
    return escape_str;
}
 
 
int main(int argc, char** argv)
{
    wchar_t str_empty[] = L"";
    wchar_t str_01[] = L"Lorem ipsum dolor sit amet, consectetur adipiscing elit";
    wchar_t str_02[] = L"Le code &eacute permet d'écrire un é, &Eacute pour écrire É.";
    wchar_t str_03[] = L"\'\'\'\'\'\'\'''''''";
    wchar_t* escape_str_00;
    wchar_t* escape_str_01;
    wchar_t* escape_str_02;
    wchar_t* escape_str_03;
 
//  wprintf(L"%ls\n%ls\n%ls\n%ls\n", str_empty, str_01, str_02, str_03);
    UTF_16_display_hexa(str_01, "\n\n");
    UTF_16_display_hexa(str_02, "\n\n");
    UTF_16_display_hexa(str_03, "\n\n");
 
    escape_str_00 = UTF_16_escape(str_empty);
    escape_str_01 = UTF_16_escape(str_01);
    escape_str_02 = UTF_16_escape(str_02);
    escape_str_03 = UTF_16_escape(str_03);
 
    printf("\n");
 
    if (escape_str_00 == NULL) { printf("main - debug: test empty ok\n"); }
    if (escape_str_01 != NULL) { printf("main - debug: test str_01 ok (len: %lu)\n", wcslen(escape_str_01)); }
    if (escape_str_02 != NULL) { printf("main - debug: test str_02 ok (len: %lu)\n", wcslen(escape_str_02)); }
    if (escape_str_03 != NULL) { printf("main - debug: test str_03 ok (len: %lu)\n", wcslen(escape_str_03)); }
 
    printf("\n");
 
//  wprintf(L"%ls\n%ls\n%ls\n%ls\n", str_empty, escape_str_01, escape_str_02, escape_str_03);
    UTF_16_display_hexa(escape_str_01, "\n\n");
    UTF_16_display_hexa(escape_str_02, "\n\n");
    UTF_16_display_hexa(escape_str_03, "\n\n");
 
    if (escape_str_01 != NULL) { free(escape_str_01); }
    if (escape_str_02 != NULL) { free(escape_str_02); }
    if (escape_str_03 != NULL) { free(escape_str_03); }
 
    return EXIT_SUCCESS;
}

24/04/2021, 23h12
kaitlyn

Salut,

Citation:

Envoyé par Portocolo951

Sous Linux, il n'y a pas ce souci. Tout fonctionne très bien avec des chars.

Par contre, sous Windows, c'est une tout autre histoire... C'est sous cet OS que le problème se pose.

J'utilise Visual Studio Community.

Avez-vous une solution viable à me proposer ?

Tu restes en char, tu récupères ta ligne avec fgets(). Pour linux rien ne change. Pour windows tu ajoutes une étape pour convertir ta ligne en utf-8 avec MultiByteToWideChar() et WideCharToMultiByte.