Insertion Vector dans BDD

Version imprimable

Bonjour je vais essayer d'être le plus clair pour faciliter la résolution de mon problème et le moins possible embêter les gens d'ici (en essayant d'aider d'autre pendant ce temps la mais j'en doute)

Ce que je veux faire :
Insérer un vecteur d'entier (plutot gros environ 60 000 valeurs)dans un blob dans une base de donnée mysql.

Pourquoi :
Je dois garder une suite d'identifiant dont l'ordre est significatif (et carrément essentiel a mon projet) qui n'ont de sens que tous ensemble. La rapidités d'exécution étant essentielle il est apparu que limité le nombre des requêtes devrait être plus efficace (plus de requêtes avec très peu donnée semble être moins efficace que peu de requête avec un flux plus conséquent a chaque fois). Dans le projet par la suite on recuperera systematiquement tout les identifiants ensemble. Les prendre individuellement n'a aucun sens.

Mon problème :
La librairie mysqlpp ne semblent pas du tout conçus pour ca et lui passer un vecteur ou meme un array me donne une bonne page d'erreur a la compilation(j'ai compris j'ai pas le droit de faire ca).
A part en passant l'ensemble de mes valeurs dans une chaine de caractère. Ce qui est assez clairement 1 Très moche 2 pas optimiser pour deux sous 3 Assez bancal
Pour l'instant tout mes essais dans ce but se sont reveler infructeux

J'utilise :
Gcc 4.1.2
La librairie mysqlpp 3.0.9 (d'ailleurs j'avoue avoir du mal a l'installer cette pu**)

Je précise :
- Je ne suis pas sur du tout d'avoir la solution idéale, et mon patron même si il m'a proposé cette version est tout a fait prêt a me laisser faire autrement si c'est argumenté et que ma version est efficace.
- Que je suis un sale bio-informaticien donc avec une formation technique un peu légère (et que j'avoue pas aimer du tout le bas niveau avec pointeur,malloc et cie ... D'ailleur a ce niveau je pense faire bien plus du C++ que du c)
- Que la solution du "une colonne avec chaque identifiant" me semble d'autant plus pas pratique que au final ma base de donnée doit contenir plus de 70 000 de ce genres de blob et donc risque de faire la tronche si je fait une ligne pour chaque valeur. (non ?) et avoir surtout pas grand sens c'est la serie qui a un interet ensemble.
- Le but final étant de faire un outil de comparaison des donnée issue de micro-array sur geo mais la si vous n'avez pas de background en biologie vous n'allez pas comprendre grand chose (et c'est plus pour l'anecdote)

Voila je met un exemple minimal du code qui fait joyeusement hurler mon compilateur :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 #include <mysql++/mysql++.h> #include <vector> #include <iostream> using namespace std; int main(int argc, char *argv[]) { int id_ech=223; int id_gpl=245; int num_zero=278; // information sur la connexion : const char* db = "test", *server = 0, *user = "koemgun", *pass = ""; int entier[] = {1,54,87,32,151,654,24,3,54387,1873}; // on crée un array contenant des valeurs bidons std::vector<int> v (entier,entier+sizeof(entier)/sizeof(int)); // que l'on met dans le vecteur v mysqlpp::Connection conn(db, server, user, pass); // on se connecte mysqlpp::Query query = conn.query(); // on cree la requete query << "INSERT INTO echantillon values ("<<id_ech<<","<<id_gpl<<","<<num_zero<<"," << v << ")"; // je met dans ma requete ce que je veux cout << "Query: " << query << endl; // j'affiche mon biniou avant l'execution query.execute(); // paf une balle dans la nuque }
Voila en espérant être clair.
D'avance merci.

Koemgun qui s'en va de se pas voir si il peut aider d'autres âmes égarés sur ce forum.

19/04/2010, 14h03
jblecanard

Salut !

Citation:

Envoyé par Koemgun

plus de requêtes avec très peu donnée semble être moins efficace que peu de requête avec un flux plus conséquent a chaque fois

C'est tout à fait vrai. De plus, dans ton cas, tu réduis drastiquement le nombre de lignes dans ta table et, aussi les risques d'incohérences (puisque tes entiers sont corrélés et triés). Bref, je pense que c'est le bon choix :).

Si le code fait hurler ton compilateur, c'est parce que le std::vector ne supporte en effet pas l'opérande <<.

Tu n'as malheureusement pas vraiment le choix, il va te falloir sérialiser ton vecteur. Y a un vague exemple ici : http://lasitheranda.wordpress.com/20...e-using-mysql/. C'est sûr, faire un C-cast sur du char*, c'est un peu sale, mais mysqlpp ne semble pas proposer beaucoup d'alternatives à cette méthode. En cherchant un peu dans l'API, j'ai rien vu.

Il faut que tu fasses attention si tu veux quelque chose de portable. C'est à dire que tu seras lié à l'encodage de tes entiers (notion de little endian, big endian, voir ici http://fr.wikipedia.org/wiki/Endianness).
20/04/2010, 17h02
Koemgun
Merci de confirmer la validité de mes postulats au moins je sais que je ne fais pas fausse route.
Normalement il n'y a pas trop de question de portabilité la machine qui importe les donnée est la même qui les exportes.
Et oui j'avais compris que le vecteur était pas supporté mais l'exemple etait parlant de ce que je voulais faire. (marrant de voir une instruction fausse généré une page d'erreur a la compilation)

Donc maintenant que j'ai ma solution sérialiser tout le machin a partir du lien que tu m'a donné basiquement tout repose la dessus :
Code:

1 2 3 4 5 6 ostringstream os; int data[]={9,2,4,3,7,6,1,5,8} int dataLength=sizeof(int)*9; os.write(reinterpret_cast<char *> (data), dataLength); string leopard = os.str();
et après on met léopard ou on veut dans notre requête.
Le problème est que pour récupérer le flux je me base sur ca :
Code:

1 2 const int *v=reinterpret_cast<const int*>(row[0].c_str());
Et après chaque case de v contient bien mes valeurs.
Mais par contre la ou j'ai un problème c'est que cet idiot a l'air de mal calculer la taille de ma chaine. Pire il a l'air de couper juste au nombre de caractère concerné en en comptant un caractère entre chaque chiffre
Par exemple avec un :

Code:

int data[]={9,2,4,3,7,6,1,5,8,222}

Et bah je dois faire

Code:

int dataLength=sizeof(int)*21;

Donc en gros je dois tenir compte du nombre de chiffre brut pour savoir ou couper. Comme je n'aurais que des suites genre de [1 à 987] je peux faire une fonction qui calcule quelle est la taille de ma chaine de caractère mais je trouve ca un peu bancal.
Il n'y a pas une manière plus propre de faire ca ? Un equivalent de .size() pour les int[] ?

D'avance merci
Une fois ca fini je mettrais ma solution ici et le probleme sera résolu ^^
20/04/2010, 17h44
jblecanard
Salut
Citation:
Envoyé par Koemgun

Merci de confirmer la validité de mes postulats au moins je sais que je ne fais pas fausse route.
Normalement il n'y a pas trop de question de portabilité la machine qui importe les donnée est la même qui les exportes.
Et oui j'avais compris que le vecteur était pas supporté mais l'exemple etait parlant de ce que je voulais faire. (marrant de voir une instruction fausse généré une page d'erreur a la compilation)

Donc maintenant que j'ai ma solution sérialiser tout le machin a partir du lien que tu m'a donné basiquement tout repose la dessus :

Code:

1 2 3 4 5 6 ostringstream os; int data[]={9,2,4,3,7,6,1,5,8} int dataLength=sizeof(int)*9; os.write(reinterpret_cast<char *> (data), dataLength); string leopard = os.str();
Là je dis bof, car on passe par le mécanisme de std::string, qui n'est pas censé géré des flux d'octets. Il faudrait avoir accès au ostream que mysqlpp::Query utilise pour bien faire.

Ensuite je vois sizeof(int)*21. ça veut dire un int supplémentaire entre chaque, et sûrement pas un caractère. Un int ou un un void*. Ce qui laisse à penser que c'est une structure chaînée qui a été stockée ! Je ne vois pas tout de suite comment régler ça, je vais devoir bouger :/. Essaye en filant directement le ostream à mysqlpp...
22/04/2010, 13h43
Koemgun

Tout comme pour vector l'operateur << n'aime pas les ostream.
Par contre certe le string n'est pas prévu pour gerer les flux binaire mais ca marche. Évidemment je ne dois pas faire de lecture de string auquel cas il s'arreterais au premier \0. Mais en reconvertissant dans l'autre sens ca marche je retrouve bien un tableau d'entiers. Dans le bon sens les valeurs conservée et tout et tout.

Je le reconnais je suis un très vilain bricoleur et la ligne qui te faisait penser a des horreurs genre une liste chainée stockée :

Code:

int dataLength=sizeof(int)*21;

Marche exactement comme si je fais :

Code:

int dataLength=21;

Peut être parce-que la taille d'un entier est 1 (^^) et que comme je découpe la chaine en utilisant

Code:

os.write(reinterpret_cast<char *> (data), dataLength);

En fait c'est essentiellement cette ligne que je ne comprend pas. elle marche mais son fonctionnement reste obscur. Pourquoi avoir un char* alors que c'est des entiers ? Je vois bien que ca permet de reinterpeter un pointeur mais la comme je le lis ca doit lire des entiers comme des suites de caractères. Et pourtant cela arrive a garder la séparation entre mes entiers quand je "recuperer" les donnée a la sortie de la BDD.
J'ai beau lire le manuel je reste toujours dans l'obscuritée.
22/04/2010, 14h26
jblecanard

Salut !

Non, un int n'a pas la taille 1, mais la taille 4, tands qu'un char a bien la taille 1.

Citation:

Envoyé par Koemgun

Code:

os.write(reinterpret_cast<char *> (data), dataLength);

En fait c'est essentiellement cette ligne que je ne comprend pas. elle marche mais son fonctionnement reste obscur. Pourquoi avoir un char* alors que c'est des entiers ? Je vois bien que ca permet de reinterpeter un pointeur mais la comme je le lis ca doit lire des entiers comme des suites de caractères. Et pourtant cela arrive a garder la séparation entre mes entiers quand je "recuperer" les donnée a la sortie de la BDD.
J'ai beau lire le manuel je reste toujours dans l'obscuritée.

La raison est simple. Tu utilises un char* parce que c'est la signature de la fonction write. Et pourquoi c'est la signature de la fonction write ? Et bien justement parce que le char est la donnée la plus petite que tu puisses manipuler côté C++ (1 octet). Ce qui te permet donc de sérialiser sous forme de suites de char n'importe quelle autre donnée. Donc un interger sera modélisé par une suite de 4 char.

Néanmmoins, ça ne résoud pas ce problème de 21. Je regarderais de plus près avec plaisir dès que j'en aurais le temps.

NB : Tu travaillerais pas sur du 64 bits par hasard ?
22/04/2010, 17h46
Koemgun

[Mode disgression = On ]En fait je n'ai aucune idée de la machine sur lequel mon code tourne. :lol: Je travaille en vnc sur un serveur centos5 ... Ah on me dit dans mon oreillette google© qu'il suffit de taper cat /proc/cpuinfo/ ... Donc oui je m'en doutais c'est de l'archi 64bit c'est un bon gros serveur que j'ai a base de
quad core amd opteron 2380
(mais je comprend pas pourquoi il m'affiche 8 fois le processeur ... Ah c'est donc un bi-proc ... omg ah oui quand meme ...)
[/mode disgression]

Oui j'ai une machine 64 bit

D'apres ce que tu me dis le 21 en fait semblerait indiquer qu'il prend chaque caractère un par un et que le reinterpret_char utilise une methode pour convertir notre int[] en binaire et qu'il a besoin de la longueur totale...
En fait je comprend pas et ton aide serait reellement la bienvenue ^^
22/04/2010, 18h35
jblecanard

Citation:

Envoyé par Koemgun

D'apres ce que tu me dis le 21 en fait semblerait indiquer qu'il prend chaque caractère un par un et que le reinterpret_char utilise une methode pour convertir notre int[] en binaire et qu'il a besoin de la longueur totale...
En fait je comprend pas et ton aide serait reellement la bienvenue ^^

Non pas du tout, en fait le reinterpet_cast est un cast assez sale, c'est une manière de dire au compilo "t'inquiètes je sais ce que je fais". Le cast ne convertit rien de rien.

Tu n'as besoin de la longueur qu'au moment du write, pas au moment du cast. Tu cast ton int* en char*, et tu multiplie le nombre d'int par sizeof(int), soit 4. Jusqu'ici tout va bien.

Ce qui fout la merde et rajoute des données, c'est à mon avis le passage dans string, ce pour quoi je disais que ce n'était pas bien...

Bonjour

Levé de bonne heure aujourd'hui, j'ai une solution à te proposer. Il te suffirait de créer une structure de donnée à toi, sur laquelle tu surcharges l'opérateur <<.

Voici un code qui fonctionne :
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 #include <vector> #include <iostream> #include <fstream> typedef struct bitStream { char * data; int DataLength; } BitStream; std::ostream &operator<<(std::ostream &sortie, BitStream stream) { sortie.write(stream.data,stream.DataLength); return sortie; } int main(int argc, char *argv[]) { int data[]={9,2,4,3,7,6,1,5,8}; BitStream monStream; monStream.data = reinterpret_cast<char*>(data); monStream.DataLength = sizeof(int)*9; // là au lieu d'un fichier, tu devrais pouvoir utiliser ta Query. std::ofstream fichierOut("test.bin"); fichierOut << monStream; fichierOut.close(); std::ifstream fichierIn("test.bin"); int readData[9]; fichierIn.read(reinterpret_cast<char*>(readData),sizeof(int)*9); for(unsigned int i=0; i < 9; i++) { int entier = readData[i]; std::cout << entier << " "; } std::cout << std::endl; }
J'ai utilisé un struct parce que c'est simple, mais rien ne t'empêches d'utiliser carrément un objet qui encapsule en plus le passage char <-> int.

Au passage, je te déconseille l'usage de "using namespace std;", ainsi que je l'ai fait dans mon code.

NB : Attention ici je n'ai aucun delete car je n'utilise que des allocations statiques. Prend garde à la gestion mémoire quand tu travailles avec de l'allocation dynamique.

26/04/2010, 21h13
epsilon68

(la base de données, c'est obligé que ce soit MySQL?)

pourquoi tu ne serializes pas toi meme ton vecteur?

du genre

Code:

v.join(",")

la fonction join n'est pas dans le standard mais je crois qu'elle se fait assez facilement non?
26/04/2010, 21h21
epsilon68

Citation:

Envoyé par jblecanard

Salut !
C'est tout à fait vrai. De plus, dans ton cas, tu réduis drastiquement le nombre de lignes dans ta table et, aussi les risques d'incohérences (puisque tes entiers sont corrélés et triés). Bref, je pense que c'est le bon choix :).

ca dépend de ce que tu fais avec tes données apres.
je ne vois pas comment traiter les données si ils sont en blob ou clob.
maintenant si c'est juste de l'archive ... alors c'est ok ...

Alors travaillant sur autre chose actuellement je n'ai pas eu l'occasion de tester la solution de jblecanard mais si elle marche comme ce que j'avais fait précédemment alors traité le blob n'est pas un problème.
Le blob une fois récupéré se lit comme un int[] donc plutôt facile a traiter ;) (oui en plus de mon blob je note le nombre de mes entiers stocké dans le blob a coté) car on a tout stocké nos entier de manière binaire donc voila après c'est pas de l'archivage c'est on récupère la série et on fait des calculs dessus.
Et sérialiser comme tu le propose impliquerais de tout garder en étant stocker comme une chaine de caractère or justement je veux du binaire pour gagner en vitesse et en stockage (stocker un entier en texte c'est au minimum l'assurance de doubler la taille de stockage)

Oui MySql ne fais pas parti des choses que je peux changer.

Merci jb je vais tester ta solution aujourd'hui voir ce que cela donne...

Edit 14h40 :
J'ai reutilisé ton code et mysqlpp ne veut pas de la surcharge d'operateur :
Code:

1 2 3 4 5 insertion2.cpp: In function ‘int main(int, char**)’: insertion2.cpp:31: erreur: no match for ‘operator<<’ in ‘mysqlpp::operator<<(((std::ostream&)((std::basic_ostream<char, std::char_traits<char> >*)std::operator<< [with _Traits = std::char_traits<char>](((std::basic_ostream<char, std::char_traits<char> >&)(& query.mysqlpp::Query::<anonymous>)), ((const char*)"INSERT INTO echantillon values (1,2,3,\"")))), escape) << monStream’ insertion2.cpp:13: note: candidats sont: std::ostream& operator<<(std::ostream&, BitStream) /usr/local/include/mysql++/query.h:1089: note: std::ostream& mysqlpp::operator<<(std::ostream&, mysqlpp::Query&) /usr/local/include/mysql++/manip.h:482: note: mysqlpp::SQLQueryParms& mysqlpp::operator<<(mysqlpp::ignore_type2, mysqlpp::SQLTypeAdapter&)
Et ca continue sur 3 pages d'erreur en reference a mysqlpp

Comme je sais que la surcharge d'opérateur je maitrise pas bien voila mon code minimal au cas ou j'aurais oublier quelque chose mais la je vois pas bien
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 #include <vector> #include <iostream> #include <mysql++/mysql++.h> typedef struct bitStream { char * data; int DataLength; } BitStream; std::ostream &operator<<(std::ostream &sortie, BitStream stream) { sortie.write(stream.data,stream.DataLength); return sortie; } int main(int argc, char *argv[]) { const char* db = "test", *server = 0, *user = "koemgun", *pass = ""; // info connexion int data[]={9,2,4,3,7,6,1,5,8}; // donnée a inserer dans le blob BitStream monStream; // flux stockant le entier du blob en binaire monStream.data = reinterpret_cast<char*>(data); // ecriture en binaire dans le flux monStream.DataLength = sizeof(int)*9; // avec une info sur sa taille mysqlpp::Connection conn(db, server, user, pass); mysqlpp::Query query = conn.query(); query << "INSERT INTO echantillon values (1,2,3,\"" << mysqlpp::escape << monStream << "\")"; query.execute(); return 0; }
Le pire c'est que cet idiot me dit "candidates are :bla bla" donc c'est surement très bete mais j'ai beau relire le manuel de la surcharge de ce site et d'autres je vois pas ou je boulette.

En essaynt de comprendre d'ou vient le problème je me suis rendu compte que le code proposer (de ce que j'ai compris) faisait une surcharge d'operateur que sur le std et pas sur mon mysqlpp

J'ai donc remplacé

Code:

std::ostream &operator<<(std::ostream &sortie, BitStream stream)

et je l'ai remplacé par :

Code:

1
2
 
mysqlpp::query &operateor<<(mysqlpp;;query &sortie, BitStream stream)

Ce qui arrive exactement au meme résultat a savoir :

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
insertion2.cpp:13: erreur: expected constructor, destructor, or type conversion before ‘&’ token
insertion2.cpp: In function ‘int main(int, char**)’:
insertion2.cpp:31: erreur: no match for ‘operator<<’ in ‘mysqlpp::operator<<(((std::ostream&)((std::basic_ostream<char, std::char_traits<char> >*)std::operator<< [with _Traits = std::char_traits<char>](((std::basic_ostream<char, std::char_traits<char> >&)(& query.mysqlpp::Query::<anonymous>)), ((const char*)"INSERT INTO echantillon values (1,2,3,\"")))), escape) << monStream’
/usr/local/include/mysql++/query.h:1089: note: candidats sont: std::ostream& mysqlpp::operator<<(std::ostream&, mysqlpp::Query&)
/usr/local/include/mysql++/manip.h:482: note:                 mysqlpp::SQLQueryParms& mysqlpp::operator<<(mysqlpp::ignore_type2, mysqlpp::SQLTypeAdapter&)
/usr/local/include/mysql++/manip.h:472: note:                 mysqlpp::ignore_type2 mysqlpp::operator<<(mysqlpp::SQLQueryParms&, mysqlpp::ignore_type0)
/usr/local/include/mysql++/manip.h:437: note:                 mysqlpp::SQLQueryParms& mysqlpp::operator<<(mysqlpp::do_nothing_type2, mysqlpp::SQLTypeAdapter&)
/usr/local/include/mysql++/manip.h:427: note:                 mysqlpp::do_nothing_type2 mysqlpp::operator<<(mysqlpp::SQLQueryParms&, mysqlpp::do_nothing_type0)
/usr/local/include/mysql++/manip.h:413: note:                 std::ostream& mysqlpp::operator<<(mysqlpp::do_nothing_type1, const mysqlpp::SQLTypeAdapter&)
/usr/local/include/mysql++/manip.h:406: note:                 mysqlpp::do_nothing_type1 mysqlpp::operator<<(std::ostream&, mysqlpp::do_nothing_type0)
/usr/local/include/mysql++/manip.h:372: note:                 std::ostream& mysqlpp::operator<<(mysqlpp::escape_type1, const mysqlpp::SQLTypeAdapter&)
/usr/local/include/mysql++/manip.h:365: note:                 mysqlpp::SQLQueryParms& mysqlpp::operator<<(mysqlpp::escape_type2, mysqlpp::SQLTypeAdapter&)
/usr/local/include/mysql++/manip.h:349: note:                 mysqlpp::escape_type2 mysqlpp::operator<<(mysqlpp::SQLQueryParms&, mysqlpp::escape_type0)
/usr/local/include/mysql++/manip.h:332: note:                 mysqlpp::escape_type1 mysqlpp::operator<<(std::ostream&, mysqlpp::escape_type0)
/usr/local/include/mysql++/manip.h:291: note:                 std::ostream& mysqlpp::operator<<(mysqlpp::quote_double_only_type1, const mysqlpp::SQLTypeAdapter&)
/usr/local/include/mysql++/manip.h:287: note:                 mysqlpp::SQLQueryParms& mysqlpp::operator<<(mysqlpp::quote_double_only_type2, mysqlpp::SQLTypeAdapter&)
/usr/local/include/mysql++/manip.h:273: note:                 mysqlpp::quote_double_only_type2 mysqlpp::operator<<(mysqlpp::SQLQueryParms&, mysqlpp::quote_double_only_type0)
/usr/local/include/mysql++/manip.h:256: note:                 mysqlpp::quote_double_only_type1 mysqlpp::operator<<(std::ostream&, mysqlpp::quote_double_only_type0)
/usr/local/include/mysql++/manip.h:210: note:                 std::ostream& mysqlpp::operator<<(mysqlpp::quote_only_type1, const mysqlpp::SQLTypeAdapter&)
/usr/local/include/mysql++/manip.h:207: note:                 mysqlpp::SQLQueryParms& mysqlpp::operator<<(mysqlpp::quote_only_type2, mysqlpp::SQLTypeAdapter&)
/usr/local/include/mysql++/manip.h:193: note:                 mysqlpp::quote_only_type2 mysqlpp::operator<<(mysqlpp::SQLQueryParms&, mysqlpp::quote_only_type0)
/usr/local/include/mysql++/manip.h:176: note:                 mysqlpp::quote_only_type1 mysqlpp::operator<<(std::ostream&, mysqlpp::quote_only_type0)
/usr/local/include/mysql++/manip.h:135: note:                 std::ostream& mysqlpp::operator<<(std::ostream&, const mysqlpp::SQLTypeAdapter&)
/usr/local/include/mysql++/manip.h:124: note:                 std::ostream& mysqlpp::operator<<(mysqlpp::quote_type1, const mysqlpp::SQLTypeAdapter&)
/usr/local/include/mysql++/manip.h:117: note:                 mysqlpp::SQLQueryParms& mysqlpp::operator<<(mysqlpp::quote_type2, mysqlpp::SQLTypeAdapter&)
/usr/local/include/mysql++/manip.h:107: note:                 mysqlpp::quote_type2 mysqlpp::operator<<(mysqlpp::SQLQueryParms&, mysqlpp::quote_type0)
/usr/local/include/mysql++/manip.h:90: note:                 mysqlpp::quote_type1 mysqlpp::operator<<(std::ostream&, mysqlpp::quote_type0)
/usr/local/include/mysql++/mystring.h:712: note:                 mysqlpp::ulonglong mysqlpp::operator<<(mysqlpp::ulonglong, mysqlpp::String)
/usr/local/include/mysql++/mystring.h:712: note:                 mysqlpp::ulonglong mysqlpp::operator<<(mysqlpp::String, mysqlpp::ulonglong)
/usr/local/include/mysql++/mystring.h:711: note:                 mysqlpp::longlong mysqlpp::operator<<(mysqlpp::longlong, mysqlpp::String)
/usr/local/include/mysql++/mystring.h:711: note:                 mysqlpp::longlong mysqlpp::operator<<(mysqlpp::String, mysqlpp::longlong)
/usr/local/include/mysql++/mystring.h:704: note:                 long unsigned int mysqlpp::operator<<(long unsigned int, mysqlpp::String)
/usr/local/include/mysql++/mystring.h:704: note:                 long unsigned int mysqlpp::operator<<(mysqlpp::String, long unsigned int)
/usr/local/include/mysql++/mystring.h:703: note:                 short unsigned int mysqlpp::operator<<(short unsigned int, mysqlpp::String)
/usr/local/include/mysql++/mystring.h:703: note:                 short unsigned int mysqlpp::operator<<(mysqlpp::String, short unsigned int)
/usr/local/include/mysql++/mystring.h:702: note:                 unsigned int mysqlpp::operator<<(unsigned int, mysqlpp::String)
/usr/local/include/mysql++/mystring.h:702: note:                 unsigned int mysqlpp::operator<<(mysqlpp::String, unsigned int)
/usr/local/include/mysql++/mystring.h:701: note:                 unsigned char mysqlpp::operator<<(unsigned char, mysqlpp::String)
/usr/local/include/mysql++/mystring.h:701: note:                 unsigned char mysqlpp::operator<<(mysqlpp::String, unsigned char)
/usr/local/include/mysql++/mystring.h:699: note:                 long int mysqlpp::operator<<(long int, mysqlpp::String)
/usr/local/include/mysql++/mystring.h:699: note:                 long int mysqlpp::operator<<(mysqlpp::String, long int)
/usr/local/include/mysql++/mystring.h:698: note:                 short int mysqlpp::operator<<(short int, mysqlpp::String)
/usr/local/include/mysql++/mystring.h:698: note:                 short int mysqlpp::operator<<(mysqlpp::String, short int)
/usr/local/include/mysql++/mystring.h:697: note:                 int mysqlpp::operator<<(int, mysqlpp::String)
/usr/local/include/mysql++/mystring.h:697: note:                 int mysqlpp::operator<<(mysqlpp::String, int)
/usr/local/include/mysql++/mystring.h:696: note:                 char mysqlpp::operator<<(char, mysqlpp::String)
/usr/local/include/mysql++/mystring.h:696: note:                 char mysqlpp::operator<<(mysqlpp::String, char)
/usr/local/include/mysql++/mystring.h:658: note:                 std::ostream& mysqlpp::operator<<(std::ostream&, const mysqlpp::String&)
/usr/local/include/mysql++/datetime.h:444: note:                 std::ostream& mysqlpp::operator<<(std::ostream&, const mysqlpp::Time&)
/usr/local/include/mysql++/datetime.h:330: note:                 std::ostream& mysqlpp::operator<<(std::ostream&, const mysqlpp::Date&)
/usr/local/include/mysql++/datetime.h:212: note:                 std::ostream& mysqlpp::operator<<(std::ostream&, const mysqlpp::DateTime&)

Il y'a vraiment quelque chose qui m'echappe dans la surcharge d'opérateur ...

28/04/2010, 13h15
jblecanard

Salut !

C'est sans doute une simple faute de frappe dans le post, mais il faut écrire :

Code:

mysqlpp::query &operator <<(mysqlpp::query &sortie, BitStream stream)

J'ai regardé dans le code de mysqlpp et... "<<" n'est pas surchargé pour le type mysql::Query, donc en théorie, une ligne comme

Code:

query << "Roger" << "Marcel" ;

Ne devrait même pas compiler. En revanche, "<<" est surchargé pour le type "SQLQueryParms". Est ce que tu me confirme que si, ça compile ? Si oui, je vais brancher la lib sur mon code et tester moi même pour continuer à t'aider.
28/04/2010, 14h56
Koemgun

Ah oui les ;; c'est une faute de frappe travaillant via un serveur distant en vnc qui n'est pas connecté a internet (securité paranoiaque) je peux difficilement faire des copier coller je l'ai betement recopié avec une faute.

Alors ca compile visiblement le

Code:

query << "roger" << "bob";

Mais je me rend compte qu'au niveau de ma surcharge j'ai une erreur que je ne comprend pas bien, que j'avais ignorer précédemment.

Code:

insertion2.cpp:13: erreur: expected constructor, destructor, or type conversion before '&' token

(ayant évidemment enlever la partie qui ne marche pas avec la structure)

ma ligne 13 étant celle que tu viens de corriger.

Donc j'écris mal quelque chose il refuse de reconnaitre ma surcharge et par conséquent apres rien ne marche ...
28/04/2010, 15h03
jblecanard

Et ce serais pas bêtement un problème de casse ?

Code:

mysqlpp::Query &operator <<(mysqlpp::Query &sortie, BitStream stream)

Rolalala paye ton boulet.J'avais de la fièvre hier je crois bien qu'elle continue.
Bon sur cette erreur oui une bête question de casse.
Quand on doit ajouter des chaine de caractère ca compile évidemment puisque dans le manuel c'est indiquer une requete de base:

Code:

query << "SELECT * FROM stock WHERE item = " << s;

http://tangentsoft.net/mysql++/doc/h.../tutorial.html

C'est juste la comment faire pour surcharger l'opérateur << de mysqlpp pour qu'il comprennent comment gérer la structure que tu m'a proposer (qui est effectivement bien plus propre ^^)

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
insertion2.cpp: In function ‘int main(int, char**)’:
insertion2.cpp:32: erreur: no match for ‘operator<<’ in ‘mysqlpp::operator<<(((std::ostream&)((std::basic_ostream<char, std::char_traits<char> >*)std::operator<< [with _Traits = std::char_traits<char>](((std::basic_ostream<char, std::char_traits<char> >&)(& query.mysqlpp::Query::<anonymous>)), ((const char*)"INSERT INTO echantillon values (1,2,3,\"")))), escape) << monStream’
insertion2.cpp:13: note: candidats sont: mysqlpp::Query& operator<<(mysqlpp::Query&, BitStream)
/usr/local/include/mysql++/query.h:1089: note:                 std::ostream& mysqlpp::operator<<(std::ostream&, mysqlpp::Query&)
/usr/local/include/mysql++/manip.h:482: note:                 mysqlpp::SQLQueryParms& mysqlpp::operator<<(mysqlpp::ignore_type2, mysqlpp::SQLTypeAdapter&)
/usr/local/include/mysql++/manip.h:472: note:                 mysqlpp::ignore_type2 mysqlpp::operator<<(mysqlpp::SQLQueryParms&, mysqlpp::ignore_type0)
/usr/local/include/mysql++/manip.h:437: note:                 mysqlpp::SQLQueryParms& mysqlpp::operator<<(mysqlpp::do_nothing_type2, mysqlpp::SQLTypeAdapter&)
/usr/local/include/mysql++/manip.h:427: note:                 mysqlpp::do_nothing_type2 mysqlpp::operator<<(mysqlpp::SQLQueryParms&, mysqlpp::do_nothing_type0)
/usr/local/include/mysql++/manip.h:413: note:                 std::ostream& mysqlpp::operator<<(mysqlpp::do_nothing_type1, const mysqlpp::SQLTypeAdapter&)
/usr/local/include/mysql++/manip.h:406: note:                 mysqlpp::do_nothing_type1 mysqlpp::operator<<(std::ostream&, mysqlpp::do_nothing_type0)
/usr/local/include/mysql++/manip.h:372: note:                 std::ostream& mysqlpp::operator<<(mysqlpp::escape_type1, const mysqlpp::SQLTypeAdapter&)
/usr/local/include/mysql++/manip.h:365: note:                 mysqlpp::SQLQueryParms& mysqlpp::operator<<(mysqlpp::escape_type2, mysqlpp::SQLTypeAdapter&)
/usr/local/include/mysql++/manip.h:349: note:                 mysqlpp::escape_type2 mysqlpp::operator<<(mysqlpp::SQLQueryParms&, mysqlpp::escape_type0)
/usr/local/include/mysql++/manip.h:332: note:                 mysqlpp::escape_type1 mysqlpp::operator<<(std::ostream&, mysqlpp::escape_type0)
/usr/local/include/mysql++/manip.h:291: note:                 std::ostream& mysqlpp::operator<<(mysqlpp::quote_double_only_type1, const mysqlpp::SQLTypeAdapter&)
/usr/local/include/mysql++/manip.h:287: note:                 mysqlpp::SQLQueryParms& mysqlpp::operator<<(mysqlpp::quote_double_only_type2, mysqlpp::SQLTypeAdapter&)
/usr/local/include/mysql++/manip.h:273: note:                 mysqlpp::quote_double_only_type2 mysqlpp::operator<<(mysqlpp::SQLQueryParms&, mysqlpp::quote_double_only_type0)
/usr/local/include/mysql++/manip.h:256: note:                 mysqlpp::quote_double_only_type1 mysqlpp::operator<<(std::ostream&, mysqlpp::quote_double_only_type0)
/usr/local/include/mysql++/manip.h:210: note:                 std::ostream& mysqlpp::operator<<(mysqlpp::quote_only_type1, const mysqlpp::SQLTypeAdapter&)
/usr/local/include/mysql++/manip.h:207: note:                 mysqlpp::SQLQueryParms& mysqlpp::operator<<(mysqlpp::quote_only_type2, mysqlpp::SQLTypeAdapter&)
/usr/local/include/mysql++/manip.h:193: note:                 mysqlpp::quote_only_type2 mysqlpp::operator<<(mysqlpp::SQLQueryParms&, mysqlpp::quote_only_type0)
/usr/local/include/mysql++/manip.h:176: note:                 mysqlpp::quote_only_type1 mysqlpp::operator<<(std::ostream&, mysqlpp::quote_only_type0)
/usr/local/include/mysql++/manip.h:135: note:                 std::ostream& mysqlpp::operator<<(std::ostream&, const mysqlpp::SQLTypeAdapter&)
/usr/local/include/mysql++/manip.h:124: note:                 std::ostream& mysqlpp::operator<<(mysqlpp::quote_type1, const mysqlpp::SQLTypeAdapter&)
/usr/local/include/mysql++/manip.h:117: note:                 mysqlpp::SQLQueryParms& mysqlpp::operator<<(mysqlpp::quote_type2, mysqlpp::SQLTypeAdapter&)
/usr/local/include/mysql++/manip.h:107: note:                 mysqlpp::quote_type2 mysqlpp::operator<<(mysqlpp::SQLQueryParms&, mysqlpp::quote_type0)
/usr/local/include/mysql++/manip.h:90: note:                 mysqlpp::quote_type1 mysqlpp::operator<<(std::ostream&, mysqlpp::quote_type0)
/usr/local/include/mysql++/mystring.h:712: note:                 mysqlpp::ulonglong mysqlpp::operator<<(mysqlpp::ulonglong, mysqlpp::String)
/usr/local/include/mysql++/mystring.h:712: note:                 mysqlpp::ulonglong mysqlpp::operator<<(mysqlpp::String, mysqlpp::ulonglong)
/usr/local/include/mysql++/mystring.h:711: note:                 mysqlpp::longlong mysqlpp::operator<<(mysqlpp::longlong, mysqlpp::String)
/usr/local/include/mysql++/mystring.h:711: note:                 mysqlpp::longlong mysqlpp::operator<<(mysqlpp::String, mysqlpp::longlong)
/usr/local/include/mysql++/mystring.h:704: note:                 long unsigned int mysqlpp::operator<<(long unsigned int, mysqlpp::String)
/usr/local/include/mysql++/mystring.h:704: note:                 long unsigned int mysqlpp::operator<<(mysqlpp::String, long unsigned int)
/usr/local/include/mysql++/mystring.h:703: note:                 short unsigned int mysqlpp::operator<<(short unsigned int, mysqlpp::String)
/usr/local/include/mysql++/mystring.h:703: note:                 short unsigned int mysqlpp::operator<<(mysqlpp::String, short unsigned int)
/usr/local/include/mysql++/mystring.h:702: note:                 unsigned int mysqlpp::operator<<(unsigned int, mysqlpp::String)
/usr/local/include/mysql++/mystring.h:702: note:                 unsigned int mysqlpp::operator<<(mysqlpp::String, unsigned int)
/usr/local/include/mysql++/mystring.h:701: note:                 unsigned char mysqlpp::operator<<(unsigned char, mysqlpp::String)
/usr/local/include/mysql++/mystring.h:701: note:                 unsigned char mysqlpp::operator<<(mysqlpp::String, unsigned char)
/usr/local/include/mysql++/mystring.h:699: note:                 long int mysqlpp::operator<<(long int, mysqlpp::String)
/usr/local/include/mysql++/mystring.h:699: note:                 long int mysqlpp::operator<<(mysqlpp::String, long int)
/usr/local/include/mysql++/mystring.h:698: note:                 short int mysqlpp::operator<<(short int, mysqlpp::String)
/usr/local/include/mysql++/mystring.h:698: note:                 short int mysqlpp::operator<<(mysqlpp::String, short int)
/usr/local/include/mysql++/mystring.h:697: note:                 int mysqlpp::operator<<(int, mysqlpp::String)
/usr/local/include/mysql++/mystring.h:697: note:                 int mysqlpp::operator<<(mysqlpp::String, int)
/usr/local/include/mysql++/mystring.h:696: note:                 char mysqlpp::operator<<(char, mysqlpp::String)
/usr/local/include/mysql++/mystring.h:696: note:                 char mysqlpp::operator<<(mysqlpp::String, char)
/usr/local/include/mysql++/mystring.h:658: note:                 std::ostream& mysqlpp::operator<<(std::ostream&, const mysqlpp::String&)
/usr/local/include/mysql++/datetime.h:444: note:                 std::ostream& mysqlpp::operator<<(std::ostream&, const mysqlpp::Time&)
/usr/local/include/mysql++/datetime.h:330: note:                 std::ostream& mysqlpp::operator<<(std::ostream&, const mysqlpp::Date&)
/usr/local/include/mysql++/datetime.h:212: note:                 std::ostream& mysqlpp::operator<<(std::ostream&, const mysqlpp::DateTime&

Donc la les 3 premières lignes indique tout mon probleme le lien ne se fait pas et je surcharge pas ce qu'il faut...

28/04/2010, 16h48
jblecanard

On va y arriver. regarde cette ligne :

Code:

insertion2.cpp:13: note: candidats sont: mysqlpp::Query& operator<<(mysqlpp::Query&, BitStream)

Celà signifie que ta surcharge existe bel et bien, et qu'il la connaît, mais que l'appel aux opérateurs ne rentre pas dans ce cadre.

Est ce que je peux voir :
- L'implémentation de l'opérateur
- Le code appelant avec de quoi voir comment les bazars sont initialisés

S'il te plaît ?

Merci beaucoup jb pour ta patience et ton aide déjà.

Donc voila l'intégralité de mon code tel que je compile

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
#include <vector>
#include <iostream>
#include <mysql++/mysql++.h>
 
 
typedef struct bitStream 
{
	char * data;
	int DataLength;
} BitStream;
 
//std::ostream &operator<<(std::ostream &sortie, BitStream stream)
mysqlpp::Query &operator <<(mysqlpp::Query &sortie, BitStream stream)
{
	sortie.write(stream.data,stream.DataLength);
	return sortie;
}
 
int main(int argc, char *argv[])
{
const char* db = "test_koem", *server = 0, *user = "koem", *pass = ""; // info connexion
int data[]={9,2,4,3,7,6,1,5,8}; // donnée a inserer dans le blob
 
BitStream monStream; // flux stockant le entier du blob en binaire
monStream.data = reinterpret_cast<char*>(data); // ecriture en binaire dans le flux
monStream.DataLength = sizeof(int)*9; // avec une info sur sa taille
 
try {		// On essaye de se connecter
	mysqlpp::Connection conn(db, server, user, pass);
	mysqlpp::Query query = conn.query(); 
	query << "INSERT INTO echantillon values (1,2,3,\"" << mysqlpp::escape << monStream << "\")";
	std::cout << "Query: " << query << std::endl;
	// Execute the query.  We use execute() because INSERT doesn't
	// return a result set.
	query.execute();
	}
catch (const mysqlpp::BadQuery& er) {
	// gère toutes les erreurs de requete
	std::cerr << "Error de requete : " << er.what() << std::endl;
	return -1;
}
 
catch (const mysqlpp::BadConversion& er) {	
	// Gère les problèmes de conversion
	std::cerr << "Erreur de conversion : " << er.what() << std::endl <<"\ttaille de donnée recuperée: " << er.retrieved 
		<< ", actual size: " << er.actual_size << std::endl;
	return -1;
}
 
catch (const mysqlpp::Exception& er) {
	// recupère les autres erreurs
	std::cerr << "Erreur non gérée: " << er.what() << std::endl;
	return -1;
}
 
return 0;

a tout hasard je compile comme ca pour faire les liens avec la librairie :
g++ insertion2.cpp -o insertion.exe -I/usr/include/mysql -lmysqlpp

voila

28/04/2010, 17h41
jblecanard
Re

C'est bien un problème de compilation et pas de link.

Je crois que je suis c*n et qu'il y a quelque chose de simplissime qu'on a même pas testé, alors que ça doit fonctionner :
Code:

1 2 3 query << "INSERT INTO echantillon values (1,2,3,\"" << mysqlpp::escape; query.write(monStream .data,monStream .DataLength); query << "\")";
Mais j'ai l'impression que le problème du mysqlpp::escape est un second problème qui se superpose au premier.
28/04/2010, 18h08
Koemgun

Woh putaing ca marche ! 8O

:lol:

Bon je vérifie que la récupération de donnée marche bien mais en tout cas la compilation et la requête s'executent sans probleme avec la solution que tu m'a donnée.

Edit
Bon ben verification faite la récuperation des donnée se fait sans probleme !
28/04/2010, 18h15
jblecanard

Super :D. Dire que j'y avais pensé au début mais comme je voyais pas le write dans la doc de référence, j'ai pensé que ça marcherait pas. :aie:

A mon avis, pour que ça fonctionne avec l'opérateur, il te suffirait de laisser l'opérateur avec ostream ET celui avec Query.
28/04/2010, 18h15
Koemgun

Problème résolu ! Solution détaillée
Alors au final la solution de l'enigme du jour : Comment inserer un blob de donnée binaire d'entier dans une base de donnée mysql en utilisant la librairie mysqlpp :

D'abord on fait une structure :
Code:

1 2 3 4 5 typedef struct bitStream { char * data; int DataLength; } BitStream;
Dans lequel on insère+ notre int[] de la manière suivante :
Code:

1 2 3 4 int data[]={9,2,4,3,7,6,1,5,8}; BitStream monStream; monStream.data = reinterpret_cast<char*>(data); monStream.DataLength = sizeof(int)*9;
Et on utilise comme détaillé dans leTutorial Mysqlpp la structure query en mettant nos donnée tout simplement de cette manière :
Code:

1 2 3 query << "INSERT INTO echantillon values (1,2,3,\"" << mysqlpp::escape; query.write(monStream .data,monStream .DataLength); query << "\")";
Voila ! Merci énormément jblecanard tu m'a été d'une aide précieuse j'avoue sur la fin avoir été franchement bête j'aurais pu voir la solution tellement c'etait couillon. J'ai pas assez bricolé ce qui est pourtant ma spécialité :P
28/04/2010, 18h51
jblecanard

Au final, l'utilité de la structure n'apparaît pas vraiment ici, à part pour faire du code plus propre.

Le must reste évidemment de créer un objet qui encapsule tout ça, détruit comme il faut le tableau, etc.

Content d'avoir pu t'aider celà dit :)