[PRO*C] Allocation dynamique

**fleffle** · 18/06/2008, 16h45

bonjour, bon ben voila on m'a imposé pro*C.
j'ai un problème que je ne comprends pas.
Si je fais

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
EXEC SQL BEGIN DECLARE SECTION;
	float valeur[66];
EXEC SQL END DECLARE SECTION;

Puis dans le main après avoir rempli mon tableau de float avec une requete

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
for(i=0; i<nbr_66; i++)
{
	printf("valeur :%f \n", valeur[i]);
}

J'ai bien les résultats de ma table, super...
le problème c'est que je dois connaitre la taille de mon tableau à l'avance.
J'ai donc essayé de faire un truc mais ca ne marche pas du tout.

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
 
 
int main()
{
 int i=0;
 
 size_t nbr_donnees=0; //nombres de lignes récupérées lors de la requete
 
//connexion à la bdd que je ne mets pas pour alléger
 
EXEC SQL OPEN compte;
EXEC SQL FETCH compte
INTO :nbr_donnees;
EXEC SQL CLOSE compte;
 
//nbr_donnes prend la valeur 66 cela marche donc bien !
 
 
//allocation dynamique du tableau de float
float *derniere_valeur = malloc (sizeof (float) * nbr_donnees);
 
EXEC SQL OPEN tout_station;
EXEC SQL FETCH tout_station
INTO :derniere_valeur;
EXEC SQL CLOSE tout_station;
 
for(i=0; i<nbr_donnees; i++)
{
	printf("valeur :%f \n", valeur[i]);
}

Et là ca m'affiche n'importe quoi.... je ne comprends pas d'où cela vient.
Quelqu'un peut -il m'aider ?

**Vincent Rogier** · 18/06/2008, 19h59

salut,

Peux tu poster le code SQL des curseurs ?

**fleffle** · 18/06/2008, 20h09

Bonsoir, est-ce vraiment très important ?
Car c'est une requete select avec pas mal de conditions.
La requete marche sous sql.
Le problème ne vient pas du fait que mon tableau a en paramètre une variable qui n'est pas une constante ?
Je posterai les codes des curseurs demain car je ne les ai pas sous la main.

**Vincent Rogier** · 18/06/2008, 20h28

Quant tu déclares explicitement un array de float, pro*c détecte ton tableau et fait alors un bulk fetch.

Quant tu déclares un pointeur, alors, pro*c ne détecte plus de tableau et donc, dans ce cas, il faut fetcher ligne à ligne dans une variable que tu affectes, à chaque fetch, à une entrée de ton array..

**fleffle** · 18/06/2008, 20h50

haaaaaaaaaaaaaaaaaa d'accord, je comprends mieux, je posterai demain tout le code. merci

**fleffle** · 19/06/2008, 09h03

Bonjour, je mets le code complet.

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
 
EXEC SQL BEGIN DECLARE SECTION;
/*******************************************
*Déclaration d'un curseur permettant de connaitre
*le nombre de lignes
*******************************************/
EXEC SQL DECLARE compte CURSOR FOR
select count(*)
from station, mesure, supervision
where station.flag_valid = 1
and station.d_arret > Sysdate
and mesure.d_arret > Sysdate
and mesure.cmhs = 1
and station.nom_court_sit = mesure.nom_court_sit
and supervision.tagname = ltrim(to_char(station.nsit, '00000'))||'.M'||ltrim(to_char(mesure.no_dans_sit,'000'))||'.P2';
 
 
/*******************************************
*Déclaration d'un curseur contenant notre requête
*
*******************************************/
EXEC SQL DECLARE tout_station CURSOR FOR
select station.nom_court_sit, mesure.nom_mes, supervision.value
from station, mesure, supervision
where station.flag_valid = 1
and station.d_arret > Sysdate
and mesure.d_arret > Sysdate
and mesure.cmhs = 1
and station.nom_court_sit = mesure.nom_court_sit
and supervision.tagname = ltrim(to_char(station.nsit, '00000'))||'.M'||ltrim(to_char(mesure.no_dans_sit,'000'))||'.P2';
 
/*-----------------------------------------------------------------------*/
EXEC SQL END DECLARE SECTION; 
 
EXEC ORACLE OPTION (RELEASE_CURSOR=YES);
 
EXEC ORACLE OPTION(ORACA=YES);

Je sélectionne 3 colonnes de trois tables différentes.
Donc j'ai trois tableaux. (dans l'exemple précédent j'en avais mis qu'un pour simplifier car c'est le même problème pour les trois).
Le code dans le main

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
 
 
int main()
{
 int i=0;
 
 size_t nbr_donnees=0; //nombres de lignes récupérées lors de la requete
 int connexion;
 
/*-------------------------------------------
	    Connexion a la base                  
-------------------------------------------*/
 
	connexion = connectora();
	if (connexion != 0)
	{
	exit(4);
	}
 
/************************************************
* Exécution du premier curseur permettant de connaitre
* le nombre de résultats de la requete
*************************************************/
 
EXEC SQL OPEN compte;
EXEC SQL FETCH compte
INTO :nbr_donnees;
EXEC SQL CLOSE compte;
 
 
//tableau qui récupère le supervision.value de la requete
 
float *derniere_valeur = malloc (sizeof (float) * nbr_donnees);
 if (derniere_valeur == NULL)//On vérifie que l allocation mémoire n échoue pas
    {
        fprintf(stderr, "L'allocation mémoire a échoué");
        exit(EXIT_FAILURE);
    }
 
 
//tableau qui récupère le station.nom_court_sit de la requete
 
int*num_site= malloc (sizeof (int) * nbr_donnees);
 if (derniere_valeur == NULL)//On vérifie que l allocation mémoire n échoue pas
    {
        fprintf(stderr, "L'allocation mémoire a échoué");
        exit(EXIT_FAILURE);
    }
 
 
//tableau qui récupère le mesure.nom_mes de la requete
 
int*mesure= malloc (sizeof (int) * nbr_donnees);
 if (derniere_valeur == NULL)//On vérifie que l'allocation mémoire n'échoue pas
    {
        fprintf(stderr, "L'allocation mémoire a échoué");
        exit(EXIT_FAILURE);
    }
 
 
//C est la qu il faut faire ce dont vous m avez parlé hier :
 
EXEC SQL OPEN tout_station;
EXEC SQL FETCH tout_station
INTO :num_site, :mesure, :derniere_valeur;
EXEC SQL CLOSE tout_station;

Voila

**Vincent Rogier** · 19/06/2008, 09h38

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
/* ... */
 
int i = 0;
 
/* ... */
 
 
    EXEC SQL WHENEVER NOT FOUND do break;
 
    EXEC SQL OPEN tout_station;
 
    while(1)
    {
        EXEC SQL FETCH tout_station
        INTO :num_site[i], :mesure[i], :derniere_valeur[i];
 
        i++;
    }
 
    EXEC SQL CLOSE tout_station;
 
    EXEC SQL WHENEVER NOT FOUND CONTINUE;
 
 
/* ... */

**fleffle** · 19/06/2008, 10h39

merci beaucoup cela marche très bien.

Cependant si je souhaite améliorer ma requete et rajouter une colonne comportant des chaines de caractères j'ai à chaque fois une erreur de segmentation.
je pense que le problème vient peut être du fait que les colonnes peuvent contenir des espaces. je remets le code avec la colonne de caractères en plus.

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
 
EXEC SQL BEGIN DECLARE SECTION;
/*******************************************
*Déclaration d'un curseur permettant de connaitre
*le nombre de lignes
*******************************************/
EXEC SQL DECLARE compte CURSOR FOR
SELECT count(*)
FROM station, mesure, supervision
WHERE station.flag_valid = 1
AND station.d_arret > Sysdate
AND mesure.d_arret > Sysdate
AND mesure.cmhs = 1
AND station.nom_court_sit = mesure.nom_court_sit
AND supervision.tagname = ltrim(to_char(station.nsit, '00000'))||'.M'||ltrim(to_char(mesure.no_dans_sit,'000'))||'.P2';
 
 
/*******************************************
*Déclaration d'un curseur contenant notre requête
*
*******************************************/
EXEC SQL DECLARE tout_station CURSOR FOR
SELECT station.isit, station.nom_court_sit, mesure.nom_mes, supervision.value
FROM station, mesure, supervision
WHERE station.flag_valid = 1
AND station.d_arret > Sysdate
AND mesure.d_arret > Sysdate
AND mesure.cmhs = 1
AND station.nom_court_sit = mesure.nom_court_sit
AND supervision.tagname = ltrim(to_char(station.nsit, '00000'))||'.M'||ltrim(to_char(mesure.no_dans_sit,'000'))||'.P2';
 
/*-----------------------------------------------------------------------*/
EXEC SQL END DECLARE SECTION; 
 
EXEC ORACLE OPTION (RELEASE_CURSOR=YES);
 
EXEC ORACLE OPTION(ORACA=YES);

La colonne station.isit est une colonne : VARCHAR2(20)
Un exemple de données s'y trouvant : Site de tests

voila comment je déclare mon tableau de char dynamiquement dans le main

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
92
93
94
 
 
int main()
{
 int i=0;
 
 size_t nbr_donnees=0; //nombres de lignes récupérées lors de la requete
 int connexion;
 
/*-------------------------------------------
	    Connexion a la base                  
-------------------------------------------*/
 
	connexion = connectora();
	IF (connexion != 0)
	{
	exit(4);
	}
 
/************************************************
* Exécution du premier curseur permettant de connaitre
* le nombre de résultats de la requete
*************************************************/
 
EXEC SQL OPEN compte;
EXEC SQL FETCH compte
INTO :nbr_donnees;
EXEC SQL CLOSE compte;
 
 
//tableau qui récupère le supervision.value de la requete
 
float *derniere_valeur = malloc (sizeof (float) * nbr_donnees);
 IF (derniere_valeur == NULL)//ON vérifie que l allocation mémoire n échoue pas
    {
        fprintf(stderr, "L'allocation mémoire a échoué");
        exit(EXIT_FAILURE);
    }
 
 
//tableau qui récupère le station.nom_court_sit de la requete
 
int*num_site= malloc (sizeof (int) * nbr_donnees);
 IF (derniere_valeur == NULL)//ON vérifie que l allocation mémoire n échoue pas
    {
        fprintf(stderr, "L'allocation mémoire a échoué");
        exit(EXIT_FAILURE);
    }
 
 
//tableau qui récupère le mesure.nom_mes de la requete
 
int*mesure= malloc (sizeof (int) * nbr_donnees);
 IF (derniere_valeur == NULL)//ON vérifie que l'allocation mémoire n'échoue pas
    {
        fprintf(stderr, "L'allocation mémoire a échoué");
        exit(EXIT_FAILURE);
    }
 
 //La colonne station.isit
 
char **libelle_site = malloc (sizeof * libelle_site * nbr_donnees);
 if (libelle_site == NULL)//On vérifie que l allocation mémoire n échoue pas
    {
        fprintf(stderr, "L'allocation mémoire a échoué");
        exit(EXIT_FAILURE);
    }
	//Allocation mémoire pour les  x lignes où x= nbr_donness
    for (i = 0; i < nbr_donnees; i++)
    {
        libelle_site[i]= malloc(sizeof *libelle_site[i] * 22);//VARCHAR20 donc j ai mis 22
 
        if (libelle_site[i] == NULL)//A nouveau un test d allocation mémoire
        {
            fprintf(stderr, "L allocation mémoire a échoué");
            exit(EXIT_FAILURE);
        }
    }
 
    EXEC SQL WHENEVER NOT FOUND do break;
 
    EXEC SQL OPEN tout_station;
 
    while(1)
    {
        EXEC SQL FETCH tout_station
        INTO :libelle_site[i], :num_site[i], :mesure[i], :derniere_valeur[i];
 
        i++;
    }
 
    EXEC SQL CLOSE tout_station;
 
    EXEC SQL WHENEVER NOT FOUND CONTINUE;

j'ai donc à chaque fois une erreur de segmentation.
j'espère qu'il y a compatibilité entre varchar2 et char et je pense qu'un des problèmes est les espaces dans les données.
Si vous avez des conseils sur la création du tableau de caractères je suis preneur !

Merci d'avance pour votre patience et le temps que vous consacrez c'est vraiment sympa !

**Vincent Rogier** · 19/06/2008, 12h21

pour ta colonne de type varchar, fait plutôt tout simplement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
//La colonne station.isit
 
char **libelle_site = malloc (21 * nbr_donnees);
 IF (libelle_site == NULL)//ON vérifie que l allocation mémoire n échoue pas
    {
        fprintf(stderr, "L'allocation mémoire a échoué");
        exit(EXIT_FAILURE);
    }

**fleffle** · 19/06/2008, 12h30

Erreur de segmentation à nouveau... je comprends pas d'où cela vient.

**Vincent Rogier** · 19/06/2008, 12h40

oopps.. normal ! en voyant le fetch, c'est normal que ca plante...

cela serait plutôt ca :

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
 
 //La colonne station.isit
 
char **libelle_site = malloc (sizeof(*libelle_site) * nbr_donnees);
 IF (libelle_site == NULL)//ON vérifie que l allocation mémoire n échoue pas
    {
        fprintf(stderr, "L'allocation mémoire a échoué");
        exit(EXIT_FAILURE);
    }
    //Allocation mémoire pour les  x lignes où x= nbr_donness
    FOR (i = 0; i < nbr_donnees; i++)
    {
        libelle_site[i]= malloc(21);
 
        IF (libelle_site[i] == NULL)//A nouveau un test d allocation mémoire
        {
            fprintf(stderr, "L allocation mémoire a échoué");
            exit(EXIT_FAILURE);
        }
    }

**fleffle** · 19/06/2008, 13h03

toujours pareil erreur de segmentation....
En plus dans ma réponse #8 c'est à peu près ce que j'avais écrit.

**fleffle** · 19/06/2008, 13h15

j'ai l'impression que l'erreur n'a pas de rapport avec le fetch...
Comment faire le free associé ?
car moi je fais un

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
 
  for (i = 0; i < nbr_donnees; i++)
    {	
     	free(libelle_site[i]);
	libelle_site[i]=NULL;
 
    }
 
   free(libelle_site);
 
   libelle_site= NULL;

**Vincent Rogier** · 19/06/2008, 13h18

l'erreur arrive pendant ou après la boucle du fetch ?

**fleffle** · 19/06/2008, 13h19

le free provoque l'erreur de segmentation.. mais il n'y a pas que ca je pense

**fleffle** · 19/06/2008, 13h22

j'ai mis un print juste après la boucle il n'apparait pas

j'en ai mis un dedans
printf("pendant %d\n", i);

et le résultat me sort 66 lignes (nombre de données) puis
erreur segmentation

**fleffle** · 19/06/2008, 13h34

je remets tout le code pour plus de clarté en laissant les printf de test

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
 
 
EXEC SQL BEGIN DECLARE SECTION;
/*******************************************
*Déclaration d'un curseur permettant de connaitre
*le nombre de lignes
*******************************************/
EXEC SQL DECLARE compte CURSOR FOR
SELECT count(*)
FROM station, mesure, supervision
WHERE station.flag_valid = 1
AND station.d_arret > Sysdate
AND mesure.d_arret > Sysdate
AND mesure.cmhs = 1
AND station.nom_court_sit = mesure.nom_court_sit
AND supervision.tagname = ltrim(to_char(station.nsit, '00000'))||'.M'||ltrim(to_char(mesure.no_dans_sit,'000'))||'.P2';
 
 
/*******************************************
*Déclaration d'un curseur contenant notre requête
*
*******************************************/
EXEC SQL DECLARE tout_station CURSOR FOR
SELECT station.isit, station.nom_court_sit, mesure.nom_mes, supervision.value
FROM station, mesure, supervision
WHERE station.flag_valid = 1
AND station.d_arret > Sysdate
AND mesure.d_arret > Sysdate
AND mesure.cmhs = 1
AND station.nom_court_sit = mesure.nom_court_sit
AND supervision.tagname = ltrim(to_char(station.nsit, '00000'))||'.M'||ltrim(to_char(mesure.no_dans_sit,'000'))||'.P2';
 
/*-----------------------------------------------------------------------*/
EXEC SQL END DECLARE SECTION; 
 
EXEC ORACLE OPTION (RELEASE_CURSOR=YES);
 
EXEC ORACLE OPTION(ORACA=YES);

le main juste à la suite

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
92
93
94
95
96
97
98
99
100
101
102
 
int main()
{
 int i=0;
 
 size_t nbr_donnees=0; //nombres de lignes récupérées lors de la requete
 int connexion;
 
/*-------------------------------------------
	    Connexion a la base                  
-------------------------------------------*/
 
	connexion = connectora();
	IF (connexion != 0)
	{
	exit(4);
	}
 
/************************************************
* Exécution du premier curseur permettant de connaitre
* le nombre de résultats de la requete
*************************************************/
 
EXEC SQL OPEN compte;
EXEC SQL FETCH compte
INTO :nbr_donnees;
EXEC SQL CLOSE compte;
 
 
//tableau qui récupère le supervision.value de la requete
 
float *derniere_valeur = malloc (sizeof (float) * nbr_donnees);
 IF (derniere_valeur == NULL)//ON vérifie que l allocation mémoire n échoue pas
    {
        fprintf(stderr, "L'allocation mémoire a échoué");
        exit(EXIT_FAILURE);
    }
 
 
//tableau qui récupère le station.nom_court_sit de la requete
 
int*num_site= malloc (sizeof (int) * nbr_donnees);
 IF (derniere_valeur == NULL)//ON vérifie que l allocation mémoire n échoue pas
    {
        fprintf(stderr, "L'allocation mémoire a échoué");
        exit(EXIT_FAILURE);
    }
 
 
//tableau qui récupère le mesure.nom_mes de la requete
 
int*mesure= malloc (sizeof (int) * nbr_donnees);
 IF (derniere_valeur == NULL)//ON vérifie que l'allocation mémoire n'échoue pas
    {
        fprintf(stderr, "L'allocation mémoire a échoué");
        exit(EXIT_FAILURE);
    }
 
 //La colonne station.isit
 
char **libelle_site = malloc (sizeof(*libelle_site) * nbr_donnees);
 IF (libelle_site == NULL)//ON vérifie que l allocation mémoire n échoue pas
    {
        fprintf(stderr, "L'allocation mémoire a échoué");
        exit(EXIT_FAILURE);
    }
    //Allocation mémoire pour les  x lignes où x= nbr_donness
    FOR (i = 0; i < nbr_donnees; i++)
    {
        libelle_site[i]= malloc(21);
 
        IF (libelle_site[i] == NULL)//A nouveau un test d allocation mémoire
        {
            fprintf(stderr, "L allocation mémoire a échoué");
            exit(EXIT_FAILURE);
        }
    }
 i=0;
    EXEC SQL WHENEVER NOT FOUND do break;
 
    EXEC SQL OPEN tout_station;
 
    while(1)
    {
   printf("pendant %d\n", i);
        EXEC SQL FETCH tout_station
        INTO :libelle_site[i], :num_site[i], :mesure[i], :derniere_valeur[i];
 
        i++;
    }
 
    EXEC SQL CLOSE tout_station;
 
    EXEC SQL WHENEVER NOT FOUND CONTINUE;
 
printf("avant for\n");
 
 for(i=0; i < nbr_donnees; i++)
 {
    printf("rentre ?\n");
     printf(" %s\n", libelle_site[i]);
 }

Edit: je suis sous Red Hat je sais pas si ca change quelque chose.

**fleffle** · 19/06/2008, 13h47

doublon dsl fausse manip

**fleffle** · 27/06/2008, 10h50

Bonjour, bon j'ai réussi à faire ce que je voulais mais là j'ai une autre question avec le pro*c.
j'ai une requete déclarée dans un curseur avec des conditions where.
j'aimerais dans l'une des conditions passer l'argv[1] de ma fonction main.
Je n'y arrive pas.
un exemple de requete :

select prix from produits where fruits = argv[1];

et lancer mon programme toto comme ceci :
toto cerise

voila merci