Insert into with sprintf

Bonjour,

En cas de chaîne de caractère, je mets tout simplement :

sprintf(
    query,
    "INSERT INTO pro (`id`, `nom`,`espece`, `sequence`,`simulation`,`inhibition`) VALUES ('%s','%s','%s','%s','%s','%s');" ,
    "example", "example", "example", "example", "example", "example"
);

Le cas des variables le contenu de query est:

sprintf(
    query,
    "INSERT INTO pro (`id`, `nom`,`espece`, `sequence`,`simulation`,`inhibition`) VALUES ('%s','%s','%s','%s','%s','%s');",
    id, name, espece, seq, simulationn, inhibitionn
);

où :

id = "NP_066243.1";
name = "nucleoprotein";
espece ="Zaire ebolavirus";
seq = "mdsrpiojhhhuqsffouishfihffmihIqushfdihkijwxxhckiHUQUHdfksldldjkqmskieoeicjhsoqodjqmqjksjikeosjkskkijdfkspqmqjdielqsxjxjsksqlseekkmmmqjjjezlknchmldfjkkiopolpleaollkjkjljhsldfsjhflhfh";
simulation = "mdsrpiojhhhuqsffouishfihffmihIqushfdihkijwxxhckiHUQUHdfksldldjkqmskieoeicjhsoqodjqmqjksjikeosjkskkijdfkspqmqjdielqsxjxjsksqlseekkmmmqjjjezlknchmldfjkkiopolpleaollkjkjljhsldfsjhflhfh";
inhibition = "mdsrpiojhhhuqsffouishfihffmihIqushfdihkijwxxhckiHUQUHdfksldldjkqmskieoeicjhsoqodjqmqjksjikeosjkskkijdfkspqmqjdielqsxjxjsksqlseekkmmmqjjjezlknchmldfjkkiopolpleaollkjkjljhsldfsjhflhfh";

SI rien n'est affiché, cela signifie que quelque-chose ne se passe pas bien.

Essaie d'identifier quelle variable crée le souci, en essayant une à la fois, en vérifiant à quel moment la variable

query

n'est pas correcte.

Comme tu ne montres qu'une partie de ton code, difficile pour nous d'être plus précis.

Voilà du code commenté avec des exemples, qui peuvent te servir à comprendre comment manipuler des chaînes en C.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>


int main(void) {
        /* cas 0 : s0 est un pointeur sur char. On peut utiliser cette 
         * variable pour stocker l'adresse d'une zone mémoire contenant
         * des char. Ce pointeur n'est pas initialisé à ce stade et
         * peut contenir n'importe quoi. Pour l'utiliser, il faudra y
         * mettre une adresse valide */
        char * s0;
        /* cas 1 : s1 est un pointeur sur char initialisé avec une adresse
         * vers une chaîne constante stockée "en dur" dans une partie non 
         * modifiable de la mémoire gérée par le programme */
        char * s1 = "abc";
        /* cas 2 et 3 : s2 et s3 sont des tableaux de char, dont la taille
         * est déterminée par le compilateur à la compilation. Dans le cas
         * de s2, le compilateur détermine la taille comme étant 4, car on
         * veut y mettre 3 char + le caractère terminateur de chaîne '\0'.
         * s2 et s3 ont donc la même taille. Le contenu stocké dans ces 2 
         * tableaux peut être modifié par le programme, contrairement au
         * cas précédent. */
        char s2[] = "123";
        char s3[4] = "ghi";

        /* disons que mon programme récupère une chaîne d'un utilisateur
         * stockée dans str */
        char str[256] = "Alphabet de la lettre 'a' à 'i' : ";

        /* pour que cette chaîne soit accessible à partir de la variable
         * pointeur s0, je peux juste affecter à s0 l'adresse vers le premier
         * élément du tableau str */
        s0 = str;

        /* si je veux plutôt copier cette chaîne pour en créer une copie dans 
         * une nouvelle chaîne accessible par le pointeur s0. Il me faut donc 
         * réserver un espace mémoire suffisant avec malloc, mettre l'adresse
         * de cet espace dans s0, puis effectuer cette copie avec strcpy() */
        s0 = malloc(strlen(str) + 1);
        strcpy(s0, str);

        /* si je veux copier une autre chaîne de 3 caractères dans le tableau 
         * s2, je peux le faire avec strcpy(), et il y a assez de place pour 
         * ce que je veux y mettre */
        strcpy(s2, "def");

        /* maintenant, disons que je veux concaténer s0, s1, s2 et s3 dans
         * une nouvelle chaîne stockée dans tableau pour lequel on est sûr
         * qu'il sera suffisamment grand */
        char bigstr[3000];
        sprintf(bigstr, "%s%s%s%s", s0, s1, s2, s3);
        printf("%s\n", bigstr);
        /* plutôt que d'utiliser un grand tableau, on aurait pu calculer la
         * taille des différentes chaînes avec strlen() et les additionner, 
         * ou mieux, utiliser snprintf() pour le calculer pour nous (en lui 
         * passant NULL et une taille de 0, comme ci-après et ensuite allouer 
         * la mémoire suffisante avec malloc() */
        size_t sufficientstr_size = snprintf(NULL, 0, "%s%s%s%s", s0, s1, s2, s3);
        char * sufficientstr = malloc(sufficientstr_size + 1);
        snprintf(sufficientstr, sufficientstr_size + 1, "%s%s%s%s", s0, s1, s2, s3);
        printf("%s\n", sufficientstr);

        /* on n'oublie pas de libérer la mémoire allouée, quand elle ne sert
         * plus */
        free(sufficientstr);
        free(s0);

        return 0;
}

donne :

$ gcc -Wall -Wextra 37625959.c
$ ./a.out 
Alphabet de la lettre 'a' à 'i' : abcdefghi
Alphabet de la lettre 'a' à 'i' : abcdefghi

snprintf() est utilisable avec un compilateur raisonnablement récent (intégré au C à partir de la norme C11).

https://en.cppreference.com/w/c/io/fprintf

J'ai ajouté les tailles pour les chaînes de simulation et d'inhibition, la requête fonctionne :)
Merci pour vos aides.