[BACK]Return to instructions_s8.c CVS log [TXT] [DIR] Up to [local] / rpl / src

Diff for /rpl/src/instructions_s8.c between versions 1.43 and 1.55

version 1.43, 2012/01/17 14:44:11 version 1.55, 2013/02/26 19:56:16
Line 1 Line 1
 /*  /*
 ================================================================================  ================================================================================
   RPL/2 (R) version 4.1.6    RPL/2 (R) version 4.1.12
   Copyright (C) 1989-2012 Dr. BERTRAND Joël    Copyright (C) 1989-2013 Dr. BERTRAND Joël
   
   This file is part of RPL/2.    This file is part of RPL/2.
   
Line 375  instruction_send(struct_processus *s_eta Line 375  instruction_send(struct_processus *s_eta
             }              }
         }          }
   
         tid = -3;          tid = (pthread_t) -3;
   
         attente.tv_sec = 0;          attente.tv_sec = 0;
         attente.tv_nsec = GRANULARITE_us * 1000;          attente.tv_nsec = GRANULARITE_us * 1000;
Line 627  instruction_send(struct_processus *s_eta Line 627  instruction_send(struct_processus *s_eta
     }      }
     else      else
     {      {
         tid = -1;          tid = (pthread_t) -1;
   
         attente.tv_sec = 0;          attente.tv_sec = 0;
         attente.tv_nsec = GRANULARITE_us * 1000;          attente.tv_nsec = GRANULARITE_us * 1000;
Line 785  instruction_send(struct_processus *s_eta Line 785  instruction_send(struct_processus *s_eta
 void  void
 instruction_sqlquery(struct_processus *s_etat_processus)  instruction_sqlquery(struct_processus *s_etat_processus)
 {  {
 #   define                          d_LONGUEUR  1024  
   
 #   if defined(MYSQL_SUPPORT) || defined(POSTGRESQL_SUPPORT)  
     logical1                        connexion_permanente;      logical1                        connexion_permanente;
 #   endif  
   
     struct_objet                    *s_copie_1;      struct_objet                    *s_copie_1;
     struct_objet                    *s_objet_1;      struct_objet                    *s_objet_1;
Line 837  instruction_sqlquery(struct_processus *s Line 833  instruction_sqlquery(struct_processus *s
         printf("          { \"postgresql:iso-8859-1\" \"server\" "          printf("          { \"postgresql:iso-8859-1\" \"server\" "
                 "\"database\" \"user\" \"password\" port }\n");                  "\"database\" \"user\" \"password\" port }\n");
         printf("          SQLQUERY\n");          printf("          SQLQUERY\n");
           printf("    \"select * from table\"\n");
           printf("          { \"sqlite\" \"file\" } SQLQUERY\n");
   
         return;          return;
     }      }
Line 872  instruction_sqlquery(struct_processus *s Line 870  instruction_sqlquery(struct_processus *s
   
     if ((*s_objet_1).type == LST)      if ((*s_objet_1).type == LST)
     {      {
 #   if defined(MYSQL_SUPPORT) || defined(POSTGRESQL_SUPPORT)  
         connexion_permanente = d_faux;          connexion_permanente = d_faux;
 #   endif  
   
         s_copie_1 = s_objet_1;          s_copie_1 = s_objet_1;
   
Line 885  instruction_sqlquery(struct_processus *s Line 881  instruction_sqlquery(struct_processus *s
             return;              return;
         }          }
   
           if ((*s_etat_processus).erreur_execution ==
                   d_ex_instruction_indisponible)
           {
               liberation(s_etat_processus, s_objet_1);
               liberation(s_etat_processus, s_objet_2);
               liberation(s_etat_processus, s_copie_1);
   
               return;
           }
   
         liberation(s_etat_processus, s_copie_1);          liberation(s_etat_processus, s_copie_1);
     }      }
     else      else
Line 904  instruction_sqlquery(struct_processus *s Line 910  instruction_sqlquery(struct_processus *s
             }              }
         }          }
   
 #   if defined(MYSQL_SUPPORT) || defined(POSTGRESQL_SUPPORT)  
         connexion_permanente = d_vrai;          connexion_permanente = d_vrai;
 #   endif  
     }      }
   
     if (((*s_objet_1).type == SQL) && ((*s_objet_2).type == CHN))      if (((*s_objet_1).type == SQL) && ((*s_objet_2).type == CHN))
Line 1417  instruction_sqlquery(struct_processus *s Line 1421  instruction_sqlquery(struct_processus *s
             fflush(stdout);              fflush(stdout);
 #           endif  #           endif
         }          }
           else if (strcmp((*((struct_connecteur_sql *) (*s_objet_1).objet)).type,
                   "SQLITE") == 0)
           {
               const char                  *queue;
               const unsigned char         *resultat;
   
               int                         ios;
   
               logical1                    presence_resultat;
   
               sqlite3_stmt                *ppStmt;
   
               struct_liste_chainee        *l_element_courant;
               struct_liste_chainee        *l_element_courant_ligne;
   
               struct_objet                *s_objet_resultat;
   
               struct timespec             attente;
   
               unsigned int                i;
               unsigned int                nombre_colonnes;
   
               if (sqlite3_prepare_v2((*((struct_connecteur_sql *)
                       (*s_objet_1).objet)).descripteur.sqlite,
                       (unsigned char *) (*s_objet_2).objet,
                       strlen((unsigned char *) (*s_objet_2).objet),
                       &ppStmt, &queue) != SQLITE_OK)
               {
                   if (connexion_permanente == d_faux)
                   {
                       sqlite3_close((*((struct_connecteur_sql *)
                               (*s_objet_1).objet)).descripteur.sqlite);
                   }
   
                   liberation(s_etat_processus, s_objet_1);
                   liberation(s_etat_processus, s_objet_2);
   
                   (*s_etat_processus).erreur_execution = d_ex_erreur_sql;
                   return;
               }
   
               presence_resultat = d_faux;
               s_objet_resultat = NULL;
               l_element_courant = NULL;
   
               attente.tv_sec = 0;
               attente.tv_nsec = GRANULARITE_us * 1000;
   
               do
               {
                   switch(ios = sqlite3_step(ppStmt))
                   {
                       case SQLITE_ROW:
                       {
                           if (s_objet_resultat == NULL)
                           {
                               if ((s_objet_resultat =
                                       allocation(s_etat_processus, LST)) == NULL)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_allocation_memoire;
                                   return;
                               }
   
                               presence_resultat = d_vrai;
   
                               // Création d'une liste vide
   
                               (*s_objet_resultat).objet = NULL;
                               l_element_courant = (*s_objet_resultat).objet;
                           }
   
                           // Ajout d'une liste au bout de la liste
                           // contenant les lignes
   
                           if (l_element_courant == NULL)
                           {
                               if (((*s_objet_resultat).objet =
                                       allocation_maillon(s_etat_processus))
                                       == NULL)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_allocation_memoire;
                               }
   
                               l_element_courant = (struct_liste_chainee *)
                                       (*s_objet_resultat).objet;
                           }
                           else
                           {
                               if (((*l_element_courant).suivant =
                                       allocation_maillon(s_etat_processus))
                                       == NULL)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_allocation_memoire;
                                   return;
                               }
   
                               l_element_courant = (*l_element_courant).suivant;
                           }
   
                           (*l_element_courant).suivant = NULL;
   
                           // Création de la liste fille
   
                           if (((*l_element_courant).donnee =
                                   allocation(s_etat_processus, LST)) == NULL)
                           {
                               (*s_etat_processus).erreur_systeme =
                                       d_es_allocation_memoire;
                               return;
                           }
   
                           (*(*l_element_courant).donnee).objet = NULL;
   
                           // Lecture de la ligne
   
                           nombre_colonnes = sqlite3_data_count(ppStmt);
                           l_element_courant_ligne = NULL;
   
                           for(i = 0; i < nombre_colonnes; i++)
                           {
                               if (l_element_courant_ligne == NULL)
                               {
                                   if (((*(*l_element_courant).donnee).objet =
                                           allocation_maillon(s_etat_processus))
                                           == NULL)
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_allocation_memoire;
                                       return;
                                   }
   
                                   l_element_courant_ligne =
                                           (struct_liste_chainee *)
                                           (*(*l_element_courant).donnee).objet;
                               }
                               else
                               {
                                   if (((*l_element_courant_ligne).suivant =
                                           allocation_maillon(s_etat_processus))
                                           == NULL)
                                   {
                                       l_element_courant_ligne =
                                               (*l_element_courant_ligne).suivant;
                                   }
   
                                   l_element_courant_ligne =
                                           (*l_element_courant_ligne).suivant;
                               }
   
                               (*l_element_courant_ligne).suivant = NULL;
   
                               if (((*l_element_courant_ligne).donnee =
                                       allocation(s_etat_processus, CHN))
                                       == NULL)
                               {
                                   (*s_etat_processus).erreur_systeme =
                                           d_es_allocation_memoire;
                                   return;
                               }
   
                               if (sqlite3_column_type(ppStmt, i) == SQLITE_NULL)
                               {
                                   if (((*(*l_element_courant_ligne).donnee).objet
                                           = malloc(5 * sizeof(unsigned char)))
                                           == NULL)
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_allocation_memoire;
                                       return;
                                   }
   
                                   strcpy((unsigned char *)
                                           (*(*l_element_courant_ligne).donnee)
                                           .objet, "NULL");
                               }
                               else
                               {
                                   if ((resultat = sqlite3_column_text(ppStmt, i))
                                           == NULL)
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_allocation_memoire;
                                       return;
                                   }
   
                                   if (((*(*l_element_courant_ligne).donnee).objet
                                           = malloc((strlen(resultat) + 1 ) *
                                           sizeof(unsigned char))) == NULL)
                                   {
                                       (*s_etat_processus).erreur_systeme =
                                               d_es_allocation_memoire;
                                       return;
                                   }
   
                                   strcpy((unsigned char *)
                                           (*(*l_element_courant_ligne).donnee)
                                           .objet, resultat);
                               }
                           }
   
                           break;
                       }
   
                       case SQLITE_DONE:
                       {
                           // Fin de la lecture des données
                           break;
                       }
   
                       case SQLITE_BUSY:
                       case SQLITE_LOCKED:
                       {
                           nanosleep(&attente, NULL);
                           INCR_GRANULARITE(attente.tv_nsec);
                           break;
                       }
   
                       default:
                       {
                           (*s_etat_processus).erreur_systeme =
                                   d_es_erreur_fichier;
                           return;
                       }
                   }
               } while(ios != SQLITE_DONE);
   
               if (sqlite3_finalize(ppStmt) != SQLITE_OK)
               {
                   (*s_etat_processus).erreur_systeme = d_es_erreur_fichier;
                   return;
               }
   
               if (connexion_permanente == d_faux)
               {
                   sqlite3_close((*((struct_connecteur_sql *) (*s_objet_1).objet))
                           .descripteur.sqlite);
               }
   
               if (presence_resultat == d_vrai)
               {
                   if (empilement(s_etat_processus, &((*s_etat_processus)
                           .l_base_pile), s_objet_resultat) == d_erreur)
                   {
                       return;
                   }
               }
           }
         else          else
         {          {
             liberation(s_etat_processus, s_objet_1);              liberation(s_etat_processus, s_objet_1);
Removed from v.1.43  
changed lines
  Added in v.1.55

CVSweb interface <joel.bertrand@systella.fr>