Documentation PostgreSQL 15.15 » Interfaces client » ECPG -- SQL embarqué en C » Directives de Préprocesseur

Précédent | Niveau supérieur | Suivant
36.8. Gestion des Erreurs | Sommaire | 36.10. Traiter des Programmes en SQL Embarqué

## 36.9. Directives de Préprocesseur

Plusieurs directives de préprocesseur sont disponibles, qui modifient comment le préprocesseur `ecpg` analyse et traite un fichier.

### 36.9.1. Inclure des Fichiers

Pour inclure un fichier externe dans votre fichier SQL embarqué, utilisez :

    EXEC SQL INCLUDE filename;
    EXEC SQL INCLUDE <filename>;
    EXEC SQL INCLUDE "filename";

Le préprocesseur de SQL embarqué recherchera un fichier appelé ``filename`.h`, le préprocessera, et l'incluera dans la sortie C résultante. En conséquence de quoi, les ordres SQL embarqués dans le fichier inclus seront traités correctement.

Le préprocesseurs `ecpg` cherchera un fichier dans plusieurs répertoires dans l'ordre suivant :

- répertoire courant
- `/usr/local/include`
- Le répertoire d'inclusion de PostgreSQL, défini à la compilation (par exemple, `/usr/local/pgsql/include`)
- `/usr/include`

Mais quand `EXEC SQL INCLUDE "`filename`"` est utilisé, seul le répertoire courant est parcouru.

Dans chaque répertoire, le préprocesseur recherchera d'abord le nom de fichier tel que spécifié, et si non trouvé, rajoutera `.h` au nom de fichier et essaiera à nouveau (sauf si le nom de fichier spécifié a déjà ce suffixe).

Notez que `EXEC SQL INCLUDE` est différent de:

    #include <filename.h>

parce que ce fichier ne serait pas soumis au préprocessing des commandes SQL. Naturellement, vous pouvez continuer d'utiliser la directive C `#include` pour inclure d'autres fichiers d'entête. files.

### Note

Le nom du fichier à inclure est sensible à la casse, même si le reste de la commande `EXEC SQL INCLUDE` suit les règles normales de sensibilité à la casse de SQL.

### 36.9.2. Les Directives define et undef

Similaires aux directives `#define` qui sont connues en C, le SQL embarqué a un concept similaire :

    EXEC SQL DEFINE name;
    EXEC SQL DEFINE name value;

Vous pouvez donc définir un nom:

    EXEC SQL DEFINE HAVE_FEATURE;

Et vous pouvez aussi définir des constantes:

    EXEC SQL DEFINE MYNUMBER 12;
    EXEC SQL DEFINE MYSTRING 'abc';

Utilisez `undef` pour supprimer une définition précédente :

    EXEC SQL UNDEF MYNUMBER;

Bien sûr, vous pouvez continuer d'utiliser les versions C de `#define` et `#undef` dans votre programme SQL embarqué. La différence est le moment où vos valeurs définies sont évalues. Si vous utilisez `EXEC SQL DEFINE` alors la préprocesseur `ecpg` évalue les définition et substitiue les valeurs. Par exemple si vous écrivez :

    EXEC SQL DEFINE MYNUMBER 12;
    ...
    EXEC SQL UPDATE Tbl SET col = MYNUMBER;

alors `ecpg` fera d'emblée la substitution et votre compilateur C ne verra jamais aucun nom ou identifiant `MYNUMBER`. Notez que vous ne pouvez pas utiliser `#define` pour une constante que vous allez utiliser dans une requête SQL embarquée parce que dans ce cas le précomipilateur SQL embarqué n'est pas capable de voir cette déclaration.

Si plusieurs fichiers en entrée sont nommés sur la ligne de commande du pré-processeur `ecpg`, les effets de `EXEC SQL DEFINE` et `EXEC SQL UNDEF` ne se transmettent pas entre fichiers : chaque fichier commence uniquement avec les symboles définis par les options `-D` sur la ligne de commande.

### 36.9.3. Directives ifdef, ifndef, elif, else, et endif

Vous pouvez utiliser les directives suivantes pour compiler des sections de code sous condition :

`EXEC SQL ifdef `nom`;`

  Vérifie un `nom` et traite les lignes suivante si `nom` a été créé avec `EXEC SQL define `nom``.

`EXEC SQL ifndef `nom`;`

  Vérifie un `nom` et traite les lignes suivantes si `nom` n'a pas été défini avec `EXEC SQL define `nom``.

`EXEC SQL elif `name`;`

  Commence une section alternative optionnelle après une directive `EXEC SQL ifdef `name`` ou `EXEC SQL ifndef `name``. Il peut y avoir autant de sections `elif` que nécessaire. Les lignes suivant un `elif` seront traitées si `name` a été défini et qu'aucune section précédente pour la même construction `ifdef`/`ifndef`...`endif` n'a été traitée.

`EXEC SQL else;`

  Commence une section finale, optionnelle, après une directive `EXEC SQL ifdef `name`` ou `EXEC SQL ifndef `name``. Les lignes suivantes seront traitées si aucune section précédente de la même construction `ifdef`/`ifndef`...`endif` n'a été traitée.

`EXEC SQL endif;`

  Termine une construction `ifdef`/`ifndef`...`endif`. Les lignes suivantes sont traitées normalement.

Les constructions `ifdef`/`ifndef`...`endif` peuvent être imbriquées, jusqu'à 127 niveaux.

Cet exemple compilera exactement une des trois commandes `SET TIMEZONE` :

    EXEC SQL ifdef TZVAR;
    EXEC SQL SET TIMEZONE TO TZVAR;
    EXEC SQL elif TZNAME;
    EXEC SQL SET TIMEZONE TO TZNAME;
    EXEC SQL else;
    EXEC SQL SET TIMEZONE TO 'GMT';
    EXEC SQL endif;