Construction d’instructions SQL au moment de l’exécution

Les applications qui effectuent une analyse ad hoc fréquemment générer des instructions SQL au moment de l’exécution. Par exemple, une feuille de calcul peut permettre à un utilisateur de sélectionner des colonnes à partir desquelles récupérer des données :

// SQL_Statements_Constructed_at_Run_Time.cpp  
#include <windows.h>  
#include <stdio.h>  
#include <sqltypes.h>  
  
int main() {  
   SQLCHAR *Statement = 0, *TableName = 0;  
   SQLCHAR **TableNamesArray, **ColumnNamesArray = 0;  
   BOOL *ColumnSelectedArray = 0;  
   BOOL  CommaNeeded;  
   SQLSMALLINT i = 0, NumColumns = 0;  
  
   // Use SQLTables to build a list of tables (TableNamesArray[]). Let the  
   // user select a table and store the selected table in TableName.  
  
   // Use SQLColumns to build a list of the columns in the selected table  
   // (ColumnNamesArray). Set NumColumns to the number of columns in the  
   // table. Let the user select one or more columns and flag these columns  
   // in ColumnSelectedArray[].  
  
   // Build a SELECT statement from the selected columns.  
   CommaNeeded = FALSE;  
   Statement = (SQLCHAR*)malloc(8);  
   strcpy_s((char*)Statement, 8, "SELECT ");  
  
   for (i = 0 ; i = NumColumns ; i++) {  
      if (ColumnSelectedArray[i]) {  
         if (CommaNeeded)  
            strcat_s((char*)Statement, sizeof(Statement), ",");  
         else  
            CommaNeeded = TRUE;  
         strcat_s((char*)Statement, sizeof(Statement), (char*)ColumnNamesArray[i]);  
      }  
   }  
  
   strcat_s((char*)Statement, 15, " FROM ");  
   // strcat_s((char*)Statement, 100, (char*)TableName);  
  
   // Execute the statement . It will be executed once, do not prepare it.  
   // SQLExecDirect(hstmt, Statement, SQL_NTS);  
}  

Une autre classe d’applications qui construit généralement des instructions SQL au moment de l’exécution est des environnements de développement d’applications. Toutefois, les instructions qu’ils construisent sont codées en dur dans l’application qu’elles créent, où elles peuvent généralement être optimisées et testées.

Les applications qui construisent des instructions SQL au moment de l’exécution peuvent offrir une grande flexibilité à l’utilisateur. Comme on peut le voir dans l’exemple précédent, qui n’a même pas pris en charge des opérations courantes telles que des clauses WHERE , des clauses ORDER BY ou des jointures, la construction d’instructions SQL au moment de l’exécution est beaucoup plus complexe que les instructions de codage dur. De plus, le test de ces applications pose problème, car elles peuvent construire un nombre arbitraire d’instructions SQL.

Un inconvénient potentiel de la construction d’instructions SQL au moment de l’exécution est qu’il faut beaucoup plus de temps pour construire une instruction que d’utiliser une instruction codée en dur. Heureusement, il s’agit rarement d’une préoccupation. Ces applications ont tendance à être intensives pour l’interface utilisateur et le temps passé par l’application à construire des instructions SQL est généralement faible par rapport au temps passé par l’utilisateur à entrer des critères.