| 
          
           
 
 
          
          
           
            Le code utilisé pour exécuter et répondre aux opérations en mode d’exécution synchrone et celui utilisé en mode exécution asynchrone ne présentent que peu de différences. Les principales différences entre les deux approches sont de deux types. Le premier est l’exécution d’une opération qui dépend d’une autre opération (telles que les lignes de résultat de
            
             SELECT
            
            ou la clé primaire d’une ligne ajoutée par une instruction
            
             INSERT
            
            ). Le second type de différence est la gestion des erreurs.
            
           
          
           
            
           
           
            Ecriture de code pour les opérations synchrones
           
           
            
             La principale différence entre une exécution synchrone et asynchrone est qu’en mode synchrone, la rédaction du code prend la forme d’une suite d’étapes. Par contre, dans le code asynchrone, vous enregistrez des écouteurs d’événement et vous répartissez souvent les opérations entre les méthodes des écouteurs. Lorsqu’une base de données est
             
              connectée en mode synchrone
             
             , vous pouvez exécuter successivement une série d’opérations de base de données dans un seul bloc de code. L’exemple suivant illustre cette technique :
             
            var conn:SQLConnection = new SQLConnection(); 
     
// The database file is in the application storage directory 
var folder:File = File.applicationStorageDirectory; 
var dbFile:File = folder.resolvePath("DBSample.db"); 
     
// open the database 
conn.open(dbFile, OpenMode.UPDATE); 
     
// start a transaction 
conn.begin(); 
     
// add the customer record to the database 
var insertCustomer:SQLStatement = new SQLStatement(); 
insertCustomer.sqlConnection = conn; 
insertCustomer.text = 
    "INSERT INTO customers (firstName, lastName) " +  
    "VALUES ('Bob', 'Jones')"; 
insertCustomer.execute(); 
     
var customerId:Number = insertCustomer.getResult().lastInsertRowID; 
     
// add a related phone number record for the customer 
var insertPhoneNumber:SQLStatement = new SQLStatement(); 
insertPhoneNumber.sqlConnection = conn; 
insertPhoneNumber.text =  
    "INSERT INTO customerPhoneNumbers (customerId, number) " +  
    "VALUES (:customerId, '800-555-1234')"; 
insertPhoneNumber.parameters[":customerId"] = customerId; 
insertPhoneNumber.execute(); 
     
// commit the transaction 
conn.commit(); 
            
             Comme vous pouvez le constater, vous appelez les mêmes méthodes pour effectuer les opérations de base de données, que vous utilisiez le mode synchrone ou asynchrone. Les principales différences entre les deux approches sont l’exécution d’une opération dépendant d’une autre opération et la gestion des erreurs.
             
            
           
          
           
            
           
           
            Exécution d’une opération dépendant d’une autre opération
           
           
            
             Lorsque vous êtes en mode synchrone, il n’est pas nécessaire d’écrire du code qui écoute un événement pour déterminer la fin d’une opération. Vous pouvez supposer que, lorsque l’opération d’une ligne de code se termine avec succès, l’exécution passe à la ligne de code suivante. Par conséquent, pour effectuer une opération dépendant du succès d’une autre, écrivez simplement le code dépendant immédiatement après l’opération dont il dépend. Par exemple, pour coder une application de sorte qu’elle commence une transaction, exécute une instruction
             
              INSERT
             
             , récupère la clé primaire de la ligne insérée, insère cette clé primaire dans une autre ligne d’une autre table et finisse par valider la transaction, l’ensemble du code peut être écrit sous la forme d’une série d’instructions. L’exemple suivant illustre ces opérations :
             
            var conn:SQLConnection = new SQLConnection(); 
     
// The database file is in the application storage directory 
var folder:File = File.applicationStorageDirectory; 
var dbFile:File = folder.resolvePath("DBSample.db"); 
     
// open the database 
conn.open(dbFile, SQLMode.UPDATE); 
     
// start a transaction 
conn.begin(); 
     
// add the customer record to the database 
var insertCustomer:SQLStatement = new SQLStatement(); 
insertCustomer.sqlConnection = conn; 
insertCustomer.text = 
    "INSERT INTO customers (firstName, lastName) " +  
    "VALUES ('Bob', 'Jones')"; 
insertCustomer.execute(); 
     
var customerId:Number = insertCustomer.getResult().lastInsertRowID; 
     
// add a related phone number record for the customer 
var insertPhoneNumber:SQLStatement = new SQLStatement(); 
insertPhoneNumber.sqlConnection = conn; 
insertPhoneNumber.text =  
    "INSERT INTO customerPhoneNumbers (customerId, number) " +  
    "VALUES (:customerId, '800-555-1234')"; 
insertPhoneNumber.parameters[":customerId"] = customerId; 
insertPhoneNumber.execute(); 
     
// commit the transaction 
conn.commit(); 
            
           
          
           
            
           
           
            Gestion des erreurs en mode synchrone
           
           
            
             En mode synchrone, vous n’écoutez pas un événement d’erreur pour déterminer si une opération a échoué. A l’inverse, vous renfermez le code susceptible de déclencher des erreurs dans un jeu de blocs
             
              try..catch..finally
             
             . Vous enveloppez le code rejetant l’erreur dans le bloc
             
              try
             
             . Vous écrivez les actions à effectuer en réponse à chaque type d’erreur dans des blocs
             
              catch
             
             distincts. Vous placez le code qui doit toujours s’exécuter, sans tenir compte de la réussite ou de l’échec (par exemple, la fermeture d’une connexion à la base de données devenue inutile) dans un bloc
             
              finally
             
             . L’exemple suivant démontre l’utilisation des blocs
             
              try..catch..finally
             
             pour la gestion des erreurs. Il développe l’exemple précédent en ajoutant du code de gestion d’erreur :
             
            var conn:SQLConnection = new SQLConnection(); 
     
// The database file is in the application storage directory 
var folder:File = File.applicationStorageDirectory; 
var dbFile:File = folder.resolvePath("DBSample.db"); 
     
// open the database 
conn.open(dbFile, SQLMode.UPDATE); 
     
// start a transaction 
conn.begin(); 
     
try 
{ 
    // add the customer record to the database 
    var insertCustomer:SQLStatement = new SQLStatement(); 
    insertCustomer.sqlConnection = conn; 
    insertCustomer.text = 
        "INSERT INTO customers (firstName, lastName)" +  
        "VALUES ('Bob', 'Jones')"; 
     
    insertCustomer.execute(); 
     
    var customerId:Number = insertCustomer.getResult().lastInsertRowID; 
     
    // add a related phone number record for the customer 
    var insertPhoneNumber:SQLStatement = new SQLStatement(); 
    insertPhoneNumber.sqlConnection = conn; 
    insertPhoneNumber.text =  
        "INSERT INTO customerPhoneNumbers (customerId, number)" +  
        "VALUES (:customerId, '800-555-1234')"; 
    insertPhoneNumber.parameters[":customerId"] = customerId; 
     
    insertPhoneNumber.execute(); 
     
    // if we've gotten to this point without errors, commit the transaction 
    conn.commit(); 
} 
catch (error:SQLError) 
{ 
    // rollback the transaction 
    conn.rollback(); 
} 
            
           
          
          
           
          
          
          
          | 
         
          | 
         
          
          |