bonjour,
j'utilise le Pro*c sur un systeme VMS.
Je mets en dessous le code d'une fonction que j'utilise, pour faire la lecture sur une table. Cela fonctionne, mais il arrive que cette fonction utilisée plusieurs fois dans le meme programme, genere un "access violation" (pas a tous les coups).
j'aimerais savoir si vous voyez quelque chose de bizare dans ma facon de faire ??
 
 
 
mon code :
__________
/* structure de ma table */
typedef struct
{
 char champ1[5];
 int champ2;
 char champ3;
} matable_occ;
 
/* structure de l'indicator de ma table */
typedef struct
{
 short champ1;
 short champ2;
 short champ3;
} matable_ind;
 
/* structure utile */
typedef struct
{
 matable_occ occ;
 matable_ind ind;
} matable;
 
 
 
 
/* cette fonction permet de faire une lecture de la table matable avec une clause where qui est passée en parametre */
/* le deuxième parametre est un tableau d'enregistrements de matable, correspondant a la requete */
/*renvoie le nombre d'enregistrement lus*/
int lec_matable(char *clause_where,matable **tab)
{
  EXEC SQL BEGIN DECLARE SECTION;
     char requete[500];
     int nb_enr;
     matable_occ curocc_occ;
     matable_ind curocc_ind;
     matable *occs;
  EXEC SQL END DECLARE SECTION;
 
 
  int i;
  int err=0;
     
 
  EXEC SQL WHENEVER SQLERROR DO err=sql_error(strcat(MODULE,"lec_matable Erreur oracle : " ));
 
 /* recupere le nombre d'enregistrement a lire */
  strcpy(requete,"SELECT COUNT(1) FROM matable " );
  strcat(requete,clause_where);
  EXEC SQL PREPARE S1 FROM :requete;
  EXEC SQL DECLARE C1 CURSOR FOR S1;
  EXEC SQL OPEN C1;
  if (err<0)
   return -1;
  EXEC SQL FETCH C1 INTO :nb_enr;
  EXEC SQL CLOSE C1;
  if (err<0)
  {
     return -1;
  }
     
 
  if (nb_enr==0)
    return 0;
 
 /* allocation en memoire du tableau d'enregistrement reponse */
  occs = (matable *)calloc(nb_enr,sizeof(matable));
 
 /* recupere les enregistrements */
  strcpy(requete,"SELECT champ1,champ2,champ3 FROM matable " );
  strcat(requete,clause_where);
  EXEC SQL PREPARE S1 FROM :requete;
  EXEC SQL DECLARE C2 CURSOR FOR S1;
  EXEC SQL OPEN C2;
  if (err<0)
   return -1;  
  EXEC SQL WHENEVER NOT FOUND DO break;
  for (i=0;;i++)
  {
    EXEC SQL FETCH C2 INTO :curocc_occ INDICATOR :curocc_ind;
    if (err<0)
    {
   EXEC SQL CLOSE C2;
     return -1;
    }
 /*recopie l'enregistrement fetché */    
    occs[i] = matable_assign(curocc_occ,curocc_ind);
  }
  *tab = occs;
 
 
 
 
  EXEC SQL CLOSE C2;
  if (err>=0)
  {
   return nb_enr;
  }
  else
 return -1;
     
}
 
 
 
 
Est ce que quelque chose vous parait choquant la dedans, un oubli, une mauvaise façon d'opérer, .... ????
Voila le compte rendu d'erreur de VMS.
 
 
 
le compte rendu d'erreur de VMS :
_________________________________
 
 
%SYSTEM-F-ACCVIO, access violation, reason mask=00, virtual address=0000000036005553, PC=00000000002508CC, PS=0000001B
%TRACE-F-TRACEBACK, symbolic stack dump follows
  image    module    routine             line      rel PC           abs PC
 LIBCLNTSH  SQLEXP  sqldbid            245574 000000000000165C 00000000002508CC
 LIBCLNTSH  SQLEXP  sqlexp             246441 00000000000047D4 0000000000253A44
 LIBCLNTSH  SQLENT  sqlcmex            243418 0000000000000534 0000000000246124
 LIBCLNTSH  SQLENT  sqlcxt             243713 0000000000000C54 0000000000246844
 LANCEUR_RAU  SQL_LEC_MATABLE  lec_matable                         26408 00000000000001A4 000000000004B4D4
 LANCEUR_RAU  LANCEUR_RAU  main         34617 00000000000000E4 00000000000300E4
 LANCEUR_RAU  LANCEUR_RAU  __main           0 0000000000000064 0000000000030064
 PTHREAD$RTL                                0 0000000000055D58 000000007BD37D58
 PTHREAD$RTL                                0 0000000000030404 000000007BD12404
                                            0 FFFFFFFF80269ED4 FFFFFFFF80269ED4
 
 
 
Merci d'avance pour votre aide.
 
 
 

je suppose que c'est un problème d'accès concurent! Tu es bien sure que le niveau d'isolation n'est pas trop haut?
Quel base utilise tu? du moins quelle version...

Je ne sais pas ce que signifie le "niveau d'isolation", je ne suis pas administrateur de la base.
C'est une base Oracle 9.2.0.5.

sinon, qu'est ce qui te fait dire que ce serait un probleme d'acces concurents???
Est ce qu'un niveau d'isolation trop élevé pourrait faire un "dump" ou bien aboutirait il a une erreur gérée???

d'après ce que je sais sur les bases de données Oracle!  
Le seul niveau d'isolation capable de déclencher une erreur c'est le niveau le plus haut, c'est à dire le niveau SERIALIZABLE!  
Mais ce niveau est très peu utilisé. Donc ça me semble bizzare comme erreur.
 
Pour bien faire, il faudrait avoir le numéro d'erreur oracle exacte pour savoir à quoi s'en tenir, donc si tu savais nous le donner!
Sinon ça pourrait également venir d'un problème avec les droits d'accès à la base! Or ici tu me dis bien que ça marche de temps en temps, donc c'est peut être un problème propre à Oracle...
Est-ce que ce problème se produit dans un cas particulier, ou est-ce aléatoire?

Edit :
J'ai eu un doute sur le sizeof de la ligne

mais, j'ai vérifié et sizeof renvoie bien la longueur de la structure.
Par ailleurs, il serait souhaitable de tester si calloc ne renvoie pas null et de libérer l'espace alloué à la fin. Il faudrait aussi s'assurer que champ1, champ2, champ3 ont la bonne taille.

désolé pour le retard de ma réponse mais j'étais passé à autre chose, j'ai donc toujours mon problème.
A priori ça ne vient pas du calloc, parceque g essayé avec un tableau de taille fixe, ça fait la même chose.
L'espace alloué, je le libère à l'extèrieur de la fonction. J'ai vérifié tous les champs au moins 20 fois, je vois rien.
 
En fait, ce problème se produit, apparement, au bout d'un certain nombre d'appelle à cette fonction.