Exécution d’une instruction

  • Article

Il existe quatre façons d’exécuter une instruction, selon le moment où elles sont compilées (préparées) par le moteur de base de données et qui les définit :

  • Exécution directe L’application définit l’instruction SQL. Il est préparé et exécuté au moment de l’exécution en une seule étape.

  • Exécution préparée L’application définit l’instruction SQL. Il est préparé et exécuté au moment de l’exécution dans des étapes distinctes. L’instruction peut être préparée une fois et exécutée plusieurs fois.

  • Les procédures que l’application peut définir et compiler une ou plusieurs instructions SQL au moment du développement et stocker ces instructions sur la source de données en tant que procédure. La procédure est exécutée une ou plusieurs fois au moment de l’exécution. L’application peut énumérer les procédures stockées disponibles à l’aide de fonctions de catalogue.

  • Fonctions de catalogue L’enregistreur de pilotes crée une fonction qui retourne un jeu de résultats prédéfini. En règle générale, cette fonction envoie une instruction SQL prédéfinie ou appelle une procédure créée à cet effet. La fonction est exécutée une ou plusieurs fois au moment de l’exécution.

Une instruction particulière (telle qu’identifiée par son handle d’instruction) peut être exécutée plusieurs fois. L’instruction peut être exécutée avec une variété d’instructions SQL différentes, ou elle peut être exécutée à plusieurs reprises avec la même instruction SQL. Par exemple, le code suivant utilise le même handle d’instruction (hstmt1) pour récupérer et afficher les tables dans la base de données Sales. Il réutilise ensuite ce handle pour récupérer les colonnes d’une table sélectionnée par l’utilisateur.

SQLHSTMT    hstmt1;  
SQLCHAR *   Table;  
  
// Create a result set of all tables in the Sales database.  
SQLTables(hstmt1, "Sales", SQL_NTS, "sysadmin", SQL_NTS, NULL, 0, NULL, 0);  
  
// Fetch and display the table names; then close the cursor.  
// Code not shown.  
  
// Have the user select a particular table.  
SelectTable(Table);  
  
// Reuse hstmt1 to create a result set of all columns in Table.  
SQLColumns(hstmt1, "Sales", SQL_NTS, "sysadmin", SQL_NTS, Table, SQL_NTS, NULL, 0);  
  
// Fetch and display the column names in Table; then close the cursor.  
// Code not shown.

Le code suivant montre comment un handle unique est utilisé pour exécuter à plusieurs reprises la même instruction pour supprimer des lignes d’une table.

SQLHSTMT      hstmt1;  
SQLUINTEGER   OrderID;  
SQLINTEGER    OrderIDInd = 0;  
  
// Prepare a statement to delete orders from the Orders table.  
SQLPrepare(hstmt1, "DELETE FROM Orders WHERE OrderID = ?", SQL_NTS);  
  
// Bind OrderID to the parameter for the OrderID column.  
SQLBindParameter(hstmt1, 1, SQL_PARAM_INPUT, SQL_C_ULONG, SQL_INTEGER, 5, 0,  
                  &OrderID, 0, &OrderIDInd);  
  
// Repeatedly execute hstmt1 with different values of OrderID.  
while ((OrderID = GetOrderID()) != 0) {  
   SQLExecute(hstmt1);  
}

Pour de nombreux pilotes, l’allocation d’instructions est une tâche coûteuse. La réutilisation de la même instruction de cette façon est généralement plus efficace que la libération des instructions existantes et l’allocation de nouvelles instructions. Les applications qui créent des jeux de résultats sur une instruction doivent faire attention à fermer le curseur sur le jeu de résultats avant de réexécuter l’instruction ; pour plus d’informations, consultez Fermeture du curseur.

La réutilisation des instructions force également l’application à éviter une limitation dans certains pilotes du nombre d’instructions pouvant être actives à la fois. La définition exacte de « active » est spécifique au pilote, mais elle fait souvent référence à n’importe quelle instruction qui a été préparée ou exécutée et qui a toujours des résultats disponibles. Par exemple, une fois qu’une instruction INSERT a été préparée, elle est généralement considérée comme active ; une fois qu’une instruction SELECT a été exécutée et que le curseur est toujours ouvert, il est généralement considéré comme actif ; une fois qu’une instruction CREATE TABLE a été exécutée, elle n’est généralement pas considérée comme active.

Une application détermine le nombre d’instructions pouvant être actives sur une seule connexion à la fois en appelant SQLGetInfo avec l’option SQL_MAX_CONCURRENT_ACTIVITIES. Une application peut utiliser plus d’instructions actives que cette limite en ouvrant plusieurs connexions à la source de données ; étant donné que les connexions peuvent être coûteuses, toutefois, l’effet sur les performances doit être pris en compte.

Les applications peuvent limiter le temps alloué pour qu’une instruction s’exécute avec l’attribut d’instruction SQL_ATTR_QUERY_TIMEOUT. Si la période d’expiration expire avant que la source de données retourne le jeu de résultats, la fonction exécutant l’instruction SQL retourne SQLSTATE HYT00 (expiration du délai d’expiration). Par défaut, aucun délai d’attente n’est défini.

Cette section contient les rubriques suivantes :