Comment compiler des modules PostgreSQL dans ServBay

Lorsque vous développez sous PostgreSQL avec l'environnement de développement Web local ServBay, il se peut que vous ayez besoin de compiler et d'installer des modules (extensions) PostgreSQL supplémentaires afin d'enrichir ou d'étendre les fonctionnalités de votre base de données. Ces modules peuvent fournir de nouveaux types de données, fonctions, opérateurs, méthodes d'accès aux index, etc.

Ce guide détaille le processus de compilation et d'installation de modules PostgreSQL dans ServBay, à travers les exemples des modules populaires postgis (pour le support SIG) et pg_jieba (segmentation de texte chinois).

Vue d'ensemble

ServBay offre un environnement flexible et riche en fonctionnalités, permettant aux développeurs d'effectuer des développements secondaires ou de compiler des composants supplémentaires sur la base des packages intégrés. Compiler un module PostgreSQL implique généralement de télécharger le code source du module, de configurer les options de compilation, d'utiliser des outils de build spécifiques (comme make ou cmake) pour la compilation et l'installation, puis d'activer le module dans la base PostgreSQL.

L'essentiel pour réussir est de bien configurer l'environnement de compilation, afin qu'il accède correctement aux fichiers d'en-tête, bibliothèques et dépendances du PostgreSQL ciblé dans ServBay.

Prérequis

Avant de compiler tout module PostgreSQL, il est impératif d'initialiser l'environnement de compilation selon les instructions de ServBay. Cette étape est indispensable car elle prépare la chaîne d'outils (compilateur, linker, etc.), configure les variables d'environnement nécessaires ($PATH, $CFLAGS, $LDFLAGS...) et définit les chemins spécifiques de l'environnement de compilation ServBay.

Pour les étapes précises, référez-vous à la section Compilation secondaire avec ServBay dans la documentation officielle. Assurez-vous d'avoir effectué toutes les préparations décrites, notamment l'exécution du script d'initialisation d'environnement dans le terminal ServBay.

Importance de la spécification de la version PostgreSQL

ServBay permet l'installation et l'exécution de plusieurs versions de PostgreSQL. Puisque la compilation et l'utilisation d'un module PostgreSQL sont intimement liées à la version ciblée (dépendance directe aux en-têtes, bibliothèques, API internes), il est indispensable de préciser explicitement la version de PostgreSQL visée ainsi que ses chemins lors de la compilation.

Choisir la bonne version garantit que la compilation pointera sur les dépendances appropriées et produira des fichiers compatibles, évitant ainsi des erreurs de compilation, de chargement ou des problèmes imprévisibles à l'exécution.

Cet exemple s'appuie sur le package PostgreSQL 15 installé dans ServBay (par exemple version 15.7). Adaptez les chemins selon la version de PostgreSQL que vous utilisez.

ServBay vous aide à localiser les chemins corrects via des variables d'environnement et l'outil pg_config : ${SERVBAY_PACKAGE_FULL_PATH}/postgresql/15/15.7/bin/pg_config fournit tous les chemins et informations de configuration pour la version spécifique souhaitée. C'est l'outil de référence pour indiquer les dépendances lors de la compilation de modules.

Compilation du module postgis

postgis est l'une des extensions les plus utilisées et puissantes de PostgreSQL, ajoutant la gestion des objets et fonctions de Systèmes d'Information Géographique (SIG), permettant ainsi le stockage, la recherche et l'analyse de données spatiales. Voici les étapes pas à pas pour compiler le module postgis-3.4.2 :

Étape 1 : Télécharger le code source

Commencez par télécharger le package source de postgis-3.4.2 depuis le site officiel PostGIS. Veillez à choisir la version source (généralement au format .tar.gz ou .zip).

wget https://download.osgeo.org/postgis/source/postgis-3.4.2.tar.gz

wget est un outil en ligne de commande couramment utilisé pour récupérer des fichiers depuis une URL.

Étape 2 : Extraire les sources

Décompressez l’archive téléchargée, puis accédez au répertoire source.

tar zxvf postgis-3.4.2.tar.gz
cd postgis-3.4.2

La commande tar zxvf extrait les archives .tar.gz. cd vous place dans le dossier source principal de postgis-3.4.2.

Étape 3 : Configurer les options de compilation

PostGIS utilise GNU Autotools comme système de build. La phase de configuration vérifie les dépendances et configure les caractéristiques à compiler, générant le fichier Makefile. Plusieurs options doivent être spécifiées pour indiquer la bonne version de PostgreSQL et les chemins des bibliothèques nécessaires.

./configure \
  --prefix=${SERVBAY_PACKAGE_FULL_PATH}/postgresql/15/15.7 \
  --bindir=${SERVBAY_PACKAGE_FULL_PATH}/postgresql/15/15.7/bin \
  --datarootdir=${SERVBAY_PACKAGE_FULL_PATH}/postgresql/15/15.7/share \
  --with-protobufdir=${SERVBAY_BIN_PATH} \
  --disable-nls \
  --without-raster \
  --without-topology \
  --with-pgconfig=${SERVBAY_PACKAGE_FULL_PATH}/postgresql/15/15.7/bin/pg_config \
  CFLAGS="${CFLAGS} -I${SERVBAY_COMMON_INCLUDE_PATH}/libxml2 -I${SERVBAY_COMMON_INCLUDE_PATH}" \
  CXXFLAGS="${CXXFLAGS} -std=c++17 -I${SERVBAY_COMMON_INCLUDE_PATH}/libxml2 -I${SERVBAY_COMMON_INCLUDE_PATH}" \
  LDFLAGS="${LDFLAGS} -L${SERVBAY_COMMON_LIB_PATH} -lxml2 -lz -lpthread -liconv -licui18n -licuuc -licudata -lm"

• ./configure : Lance le script de configuration.
• --prefix, --bindir, --datarootdir : Indiquent où installer PostGIS dans la structure attendue par la version de PostgreSQL ciblée. ${SERVBAY_PACKAGE_FULL_PATH}/postgresql/15/15.7 est le préfixe correspondant à PostgreSQL 15.7 dans ServBay, généralement défini par le script d'environnement ServBay.
• --with-protobufdir : Chemin de la librairie Protobuf si nécessaire. ${SERVBAY_BIN_PATH} pointe sur le dossier binaire des packages ServBay.
• --disable-nls : Désactive la prise en charge des langues (inutile en dev).
• --without-raster, --without-topology : Désactive les options Raster et Topology pour simplifier la compilation. Activez-les uniquement si besoin, sachant que cela ajoute des dépendances.
• --with-pgconfig : Option critique, indique précisément où trouver l'outil pg_config pour la version visée de PostgreSQL. Cela garantit la bonne compatibilité lors de la compilation.
• CFLAGS, CXXFLAGS, LDFLAGS : Variables d'environnement standards transmettant les options aux compilateurs et linkers.
  • -I${SERVBAY_COMMON_INCLUDE_PATH}/libxml2 -I${SERVBAY_COMMON_INCLUDE_PATH} : Ajoute le chemin des en-têtes partagés ServBay (ex : libxml2).
  • -L${SERVBAY_COMMON_LIB_PATH} -lxml2 -lz ... : Chemins des bibliothèques partagées ServBay et les liens nécessaires (libxml2, zlib, etc.).
  • -std=c++17 : Force l’utilisation de la norme C++17.

Étape 4 : Compilation et installation

Une fois la configuration terminée, compilez le code source avec make, puis installez le module avec make install.

make -j ${CPU_NUMBER}
make install

• make -j ${CPU_NUMBER} : Lance la compilation en parallèle, selon le nombre de cœurs CPU détectés par l'environnement ServBay (${CPU_NUMBER}).
• make install : Installe les fichiers compilés (librairies, scripts SQL...) aux emplacements attendus dans PostgreSQL 15.7 (lib/postgresql, share/postgresql/extension, etc.).

Étape 5 : Vérification du chargement du module

Après installation, activez l'extension postgis dans votre base de données PostgreSQL. Utilisez l'outil en ligne de commande psql fourni par ServBay (pensez à vous placer dans le terminal avec l'environnement ServBay chargé) :

# Crée l'extension PostGIS dans la base
${SERVBAY_PACKAGE_FULL_PATH}/postgresql/15/15.7/bin/psql -c "CREATE EXTENSION postgis;"

Si la commande aboutit sans erreur, l’extension est installée. Pour vérifier la version :

# Vérifie la version PostGIS installée
${SERVBAY_PACKAGE_FULL_PATH}/postgresql/15/15.7/bin/psql -c "SELECT PostGIS_Version();"

Le numéro de version affiché confirme le succès de la compilation, de l'installation et du chargement du module.

Compilation du module pg_jieba

pg_jieba est une extension PostgreSQL basée sur la librairie C++ cppjieba, qui permet la segmentation de texte chinois (notamment pour la recherche plein texte). pg_jieba utilise CMake comme système de build. Voici comment le compiler sous ServBay :

Étape 1 : Récupérer les sources

Commencez par cloner le dépôt GitHub de pg_jieba. Il intègre le sous-module cppjieba, donc il faut l’initialiser également :

git clone https://github.com/jaiminpan/pg_jieba.git
cd pg_jieba
git submodule update --init --recursive

• git clone ... : Récupère le code source.
• git submodule update --init --recursive : Télécharge les sous-modules Git requis, notamment cppjieba.

Étape 2 : Configuration avec CMake

Étant basé sur CMake, il faut créer un dossier de build et passer les bonnes options pour les chemins PostgreSQL et ServBay.

cmake -S . -B builddir \
  -DCMAKE_PREFIX_PATH=${SERVBAY_PACKAGE_FULL_PATH}/postgresql/15/15.7 \
  -DCMAKE_OSX_DEPLOYMENT_TARGET=${BUILD_OS_MIN_VERSION} \
  -DCMAKE_OSX_ARCHITECTURES=${BUILD_CPU_ARCH_CMAKE}

• cmake -S . -B builddir : Génère la configuration dans un sous-dossier build.
• -DCMAKE_PREFIX_PATH : Option essentielle, pour localiser headers et bibliothèques PostgreSQL (Ici, PostgreSQL 15.7 de ServBay).
• -DCMAKE_OSX_DEPLOYMENT_TARGET : Cible minimum macOS.
• -DCMAKE_OSX_ARCHITECTURES : Cible l’architecture CPU (x86_64 ou arm64) conforme à l'environnement ServBay/macOS.

Étape 3 : Compilation et installation avec CMake

Compilez et installez dans l’ordre :

cmake --build builddir -j ${CPU_NUMBER}
cmake --install builddir

• cmake --build builddir : Compile dans le dossier build.
• -j ${CPU_NUMBER} : Compilation parallèle multi-cœur.
• cmake --install builddir : Installe dans les dossiers PostgreSQL déterminés par la configuration (par exemple lib/postgresql, share/postgresql/extension).

Étape 4 : Vérifier le chargement du module

Après installation, activez l’extension dans la base PostgreSQL via le client psql :

# Active l'extension pg_jieba
${SERVBAY_PACKAGE_FULL_PATH}/postgresql/15/15.7/bin/psql -c "CREATE EXTENSION pg_jieba;"

Pour vérifier :

# Liste les extensions installées, filtre sur pg_jieba
${SERVBAY_PACKAGE_FULL_PATH}/postgresql/15/15.7/bin/psql -c "SELECT * FROM pg_available_extensions WHERE name = 'pg_jieba';"

Si le module apparaît dans la liste, compilation, installation et activation sont réussies.

FAQ (Questions fréquentes)

• La compilation échoue, message d'erreur "en-tête ou bibliothèque introuvable" ?
  • Vérifiez que l'environnement de compilation ServBay est bien initialisé (les scripts adéquats exécutés dans le terminal : variables $CFLAGS, $LDFLAGS, ${SERVBAY_COMMON_INCLUDE_PATH}, ${SERVBAY_COMMON_LIB_PATH}, etc. doivent être définies).
  • Assurez-vous que l’option --with-pgconfig (Autotools) ou -DCMAKE_PREFIX_PATH (CMake) pointe sur le bon chemin de la version PostgreSQL cible, et que le fichier pg_config y soit présent et exécutable.
  • Certains modules requièrent d'autres dépendances system externes (ex : GEOS, GDAL pour le support Raster/Topology de PostGIS). Si besoin, installez-les ou désactivez ces fonctionnalités.
• CREATE EXTENSION échoue, module introuvable ?
  • Vérifiez que l'installation (make install ou cmake --install) s’est bien déroulée, sans erreurs et que les fichiers sont bien aux bons endroits.
  • Assurez-vous que les chemins renseignés à l’étape de configuration pointent vraiment sur le répertoire correspondant à votre version PostgreSQL ServBay.
  • Essayez de redémarrer le service PostgreSQL, certaines modifications ne sont prises en compte qu’après redémarrage.
  • Contrôlez le paramètre shared_preload_libraries de PostgreSQL. Pour la plupart des extensions simples ce n’est pas nécessaire, mais pour certains modules spécifiques, il faudra les ajouter à cette liste dans la configuration.
• Comment compiler des modules pour une autre version de PostgreSQL ?
  • Reprenez ces étapes mais, lors de la configuration (./configure ou cmake), veillez à renseigner le chemin vers le pg_config ou à la racine PostgreSQL de la version souhaitée. Par exemple, ${SERVBAY_PACKAGE_FULL_PATH}/postgresql/14/14.x/bin/pg_config pour PostgreSQL 14 (14.x représentant la version exacte installée).

Conclusion

En suivant ces étapes et en profitant de l’environnement de compilation et des outils intégrés à ServBay, vous pourrez compiler et installer avec succès les modules PostgreSQL dont vous avez besoin, pour enrichir vos bases de données selon vos besoins spécifiques de développement. Gardez à l’esprit que la préparation minutieuse de l’environnement, la sélection de la bonne version cible et la vérification des chemins sont la clé du succès.

Nous espérons que ce guide vous aidera à personnaliser efficacement votre environnement PostgreSQL sous ServBay. En cas de difficultés, consultez la documentation ServBay ou la communauté pour plus d’assistance.