Accéder au moteur SQL de 4D

Le moteur SQL intégré de 4D peut être interrogé de trois manières :

• via la commande CHERCHER PAR SQL. Le principe consiste à passer la clause WHERE d’une commande SQL SELECT en tant que paramètre à la commande. Exemple :
   CHERCHER PAR SQL([OFFICES];"SALES > 100")

• via les commandes SQL intégrées de 4D, placées dans le thème “SQL” (SQL FIXER PARAMETRE, SQL EXECUTER, etc.). Ces commandes peuvent fonctionner avec une source de données OBDC ou le moteur SQL 4D de la base de données courante.

• via l’éditeur de méthodes standard de 4D. Les instructions SQL peuvent être saisies directement dans l’éditeur de méthodes de 4D. Il suffit d’insérer les requêtes SQL entre les mots-clés Debut SQL et Fin SQL. Le code compris entre ces balises ne sera pas analysé par l’interpréteur de 4D et sera exécuté par le moteur SQL (ou par un autre moteur, si défini par la commande SQL LOGIN).

Il est possible de faire référence à tout type d’expression 4D valide (variable, champ, tableau, expression...) au sein des clauses WHERE et INTO des expressions SQL. Pour désigner une référence 4D, vous pouvez utiliser indifféremment l’une des deux notations suivantes :

• placer la référence entre chevrons “<<” et “>>”
• faire précéder la référence de deux-points “:”

Exemples :

ou bien :

Note : Lorsque vous manipulez des variables interprocess (nommées <>mavar), vous devez encadrer le nom des variables avec des crochets [] (par exemple <<[<>mavar]>> ou :[<>mavar]).

En mode compilé, vous pouvez utiliser des références de variables locales (débutant par le caractère $) dans les instructions SQL sous certaines conditions :

• vous pouvez utiliser des variables locales à l'intérieur d'une séquence Debut SQL / Fin SQL, hormis avec la commande EXECUTE IMMEDIATE ;
• vous pouvez utiliser des variables locales avec la commande SQL EXECUTER lorsque ces variables sont utilisées directement dans le paramètre de requête SQL et non via des références.
  Par exemple, le code suivant fonctionnera en mode compilé :
  
   SQL EXECUTER("select * from t1 into :$mavar") // fonctionne en mode compilé
  
  Le code suivant générera une erreur en mode compilé :
  
   C_TEXTE(tRequete)
 tRequete:="select * from t1 into :$mavar"
 SQL EXECUTER(tRequete) // erreur en mode compilé

Les données issues d’une commande SELECT doivent être manipulées soit à l’intérieur d’un bloc Debut SQL/Fin SQL via la clause INTO de la commande SELECT, soit via les commandes 4D du thème “SQL” :

• Dans le cas d’une structure Debut SQL/Fin SQL, vous pouvez utiliser la clause INTO de la requête SQL pour désigner tout objet 4D valide (champ, variable ou tableau) comme destinataire des valeurs.
  
   Debut SQL
    SELECT ename FROM emp INTO <<[Employés]Nom>>
 Fin SQL

• Avec la commande SQL EXECUTER, vous pouvez également utiliser les paramètres supplémentaires :
  
   SQL EXECUTER("SELECT ename FROM emp";[Employés]Nom)

La principale différence entre les deux façons de récupérer les données issues d’une requête SQL (balises Debut SQL/Fin SQL et commandes SQL) est que dans le premier cas toutes les informations sont retournées à 4D en une seule fois, tandis que dans le second cas chaque enregistrement doit être chargé explicitement à l’aide de la commande SQL CHARGER ENREGISTREMENT.

Par exemple, en supposant que la table PERSONS comporte 100 enregistrements :

• Récupération dans un tableau en utilisant les commandes SQL génériques de 4D :
  
   TABLEAU ENTIER(tAnneeNaiss;0)
 C_TEXTE(vNom)
 vNom:="Smith"
 $SQLStm:="SELECT Birth_Year FROM PERSONS WHERE ename= <<vNom>>"
 SQL EXECUTER($SQLStm;tAnneeNaiss)
 Tant que(Non(SQL Fin de selection))
    SQL CHARGER ENREGISTREMENT(10)
 Fin tant que

  Ici, il est donc nécessaire d’effectuer 10 boucles afin de récupérer les 100 enregistrements. Pour charger tous les enregistrements en une seule fois, il suffit d’écrire :
  

   SQL CHARGER ENREGISTREMENT(SQL tous les enregistrements)

• Récupération dans un tableau en utilisant les balises Debut SQL/Fin SQL :
  
   TABLEAU ENTIER(tAnneeNaiss;0)
 C_TEXTE(vNom)
 vNom:="Smith"
 Debut SQL
    SELECT Birth_Year FROM PERSONS WHERE ename= <<vNom>> INTO <<tAnneeNaiss>>
 Fin SQL
  
  Dans ce cas, après l’exécution de l’instruction SELECT, le tableau tAnneeNaiss contient 100 éléments, chaque élément stockant une année de naissance provenant des 100 enregistrements.

Si, au lieu d’un tableau nous souhaitons récupérer les données dans un champ 4D, 4D créera automatiquement autant d’enregistrements que nécessaire pour contenir toutes les valeurs. Reprenons l’exemple d’une table PERSONS contenant 100 enregistrements :

• Récupération dans un champ en utilisant les commandes SQL génériques de 4D :
  
   C_TEXTE(vNom)
 vNom:="Smith"
 $SQLStm:="SELECT Birth_Year FROM PERSONS WHERE ename= <<vNom>>"
 SQL EXECUTER($SQLStm;[Matable]Annee_Naiss)
 Tant que(Non(SQL Fin de selection))
    SQL CHARGER ENREGISTREMENT(10)
 Fin tant que

  Ici, il est nécessaire d’effectuer 10 boucles afin de récupérer les 100 enregistrements. Chaque passage dans la boucle entraînera la création de 10 enregistrements dans la table [Matable] et chaque valeur Birth_Year récupérée de la table PERSONS sera stockée dans le champ Annee_Naiss.

• Récupération dans un champ en utilisant les balises Debut SQL/FinSQL :
  
   C_TEXTE(vNom)
 vNom:="Smith"
 Debut SQL
    SELECT Birth_Year FROM PERSONS WHERE ename= <<vNom>> INTO <<[Matable]Annee_Naiss>>
 Fin SQL

  Dans ce cas, pendant l’exécution de l’instruction SELECT, 100 enregistrements seront créés dans la table [Matable], les valeurs de la colonne Birth_Year étant stockées dans le champ 4D Annee_Naiss.

4D inclut un automatisme spécifique permettant de placer les données issues d’une requête SELECT dans une listbox. Pour plus d’informations, reportez-vous au manuel Mode Développement.

Pour des raisons d’optimisation, il est préférable d’utiliser des expressions 4D plutôt que des fonctions SQL dans les requêtes. En effet, les expressions 4D seront calculées une fois avant l’exécution de la requête tandis que les fonctions SQL sont évaluées pour chaque enregistrement trouvé.

Par exemple, avec l’instruction suivante :

... l’expression vNom+vPrenom est calculée une fois, avant l’exécution de la requête. Avec l’instruction suivante :

... la fonction CONCAT(<<vNom>>,<<vPrenom>>) est appelée pour chaque enregistrement de la table, autrement dit l’expression est évaluée pour chaque enregistrement.