Renvoie le nom de la base de données de la connexion.

char *PQdb(const PGconn *conn);
       

Renvoie le nom d'utilisateur utilisé pour la connexion.

char *PQuser(const PGconn *conn);
       

Renvoie le mot de passe utilisé pour la connexion.

char *PQpass(const PGconn *conn);
       

PQpass retournera soit le mot de passe spécifié dans les paramètres de connexion, soit, s'il n'y en avait pas, le mot de passe obtenu depuis le fichier de mots de passe. Dans ce dernier cas, si plusieurs hôtes étaient spécifiés dans les paramètres de connexion, il n'est pas possible de se fier au résultat de PQpass jusqu'à l'établissement de la connexion. Le statut de la connexion peut être vérifié avec la fonction PQstatus.

Renvoie le nom d'hôte du serveur utilisé pour la connexion. Cela peut être un nom d'hôte, une adresse IP ou un chemin de répertoire si la connexion est réalisée via un socket Unix. (Le cas du chemin se distingue par le fait que ce sera toujours un chemin absolu commençant par /.)

char *PQhost(const PGconn *conn);
       

Si les paramètres de connexion host and hostaddr sont tous les deux précisés, alors PQhost retournera host. Si seul hostaddr a été spécifié, c'est cela qui est retourné. Si plusieurs hôtes sont spécifiés dans les paramètres de connexion, PQhost retourne l'hôte à qui l'on s'est effectivement connecté.

PQhost retourne NULL si l'argument conn est NULL. Sinon, s'il y a une erreur en déterminant l'host (peut-être que la connexion n'a pas été complètement établie ou qu'il y a eu une erreur), il retourne une chaîne vide.

Si plusieurs hôtes ont été spécifiés dans les paramètres de connexion, il n'est pas possible de se baser sur le résultat de PQhost avant l'établissement de la connexion. Le statut de la connexion peut être vérifié avec la fonction PQstatus.

Renvoie le numéro de port utilisé pour la connexion active.

char *PQport(const PGconn *conn);
       

Si de multiples ports étaient spécifiés dans les paramètres de connexion, PQport renvoie le port auquel on est effectivement connecté.

PQport retourne NULL si l'argument conn est NULL. Sinon, s'il y a une erreur en déterminant le port (peut-être que la connexion n'a pas été complètement établie ou qu'il y a eu une erreur), il retourne une chaîne vide.

Si plusieurs ports ont été spécifiés dans les paramètres de connexion, il n'est pas possible de se baser sur le résultat de PQport avant l'établissement de la connexion. Le statut de la connexion peut être vérifié avec la fonction PQstatus.

Renvoie le TTY de débogage pour la connexion (ceci est obsolète car le serveur ne fait plus attention au paramétrage du TTY mais la fonction reste pour la compatibilité descendante).

char *PQtty(const PGconn *conn);
       

Renvoie les options en ligne de commande passées lors de la demande de connexion.

char *PQoptions(const PGconn *conn);
       

Renvoie l'état de la connexion.

ConnStatusType PQstatus(const PGconn *conn);
       

Le statut peut prendre un certain nombre de valeurs. Néanmoins, deux seulement ne concernent pas les procédures de connexion asynchrone : CONNECTION_OK et CONNECTION_BAD. Une bonne connexion à la base de données a l'état CONNECTION_OK. Une tentative de connexion ayant échoué est signalée par le statut CONNECTION_BAD. D'habitude, un état OK le restera jusqu'à PQfinish mais un échec dans les communications peut résulter en un statut changeant prématurément en CONNECTION_BAD. Dans ce cas, l'application peut essayer de rattraper la situation en appelant PQreset.

Voir l'entrée de PQconnectStartParams, PQconnectStart et de PQconnectPoll à propos des autres codes de statut qui pourraient être renvoyés.

Renvoie l'état actuel de la transaction du serveur.

PGTransactionStatusType PQtransactionStatus(const PGconn *conn);
       

Le statut peut être PQTRANS_IDLE (actuellement inactif), PQTRANS_ACTIVE (une commande est en cours), PQTRANS_INTRANS (inactif, dans un bloc de transaction valide) ou PQTRANS_INERROR (inactif, dans un bloc de transaction échoué). PQTRANS_UNKNOWN est rapporté si la connexion est mauvaise. PQTRANS_ACTIVE n'est rapporté que si une requête a été envoyée au serveur et n'est pas encore terminée.

Recherche la valeur en cours d'un paramètre du serveur.

const char *PQparameterStatus(const PGconn *conn, const char *paramName);
       

Certaines valeurs de paramètres sont rapportées par le serveur automatiquement ou lorsque leur valeurs changent. PQparameterStatus peut être utilisé pour interroger ces paramètres. Il renvoie la valeur en cours d'un paramètre s'il est connu et NULL si le paramètre est inconnu.

Les paramètres renvoyées par la version actuelle incluent server_version, server_encoding, client_encoding, application_name, is_superuser, session_authorization, datestyle, IntervalStyle, TimeZone, integer_datetimes et standard_conforming_strings. (server_encoding, TimeZone et integer_datetimes n'étaient pas renvoyés dans les versions antérieures à la 8.0 ; standard_conforming_strings n'était pas renvoyé dans les versions antérieures à la 8.1 ; IntervalStyle n'était pas renvoyé dans les versions antérieures à la 8.4 ; application_name n'était pas renvoyé dans les versions antérieures à la 9.0). Notez que server_version, server_encoding et integer_datetimes ne peuvent pas changer après le lancement du serveur.

Les serveurs utilisant un protocole antérieur à la 3.0 ne rapportent pas la configuration des paramètres mais libpq inclut la logique pour obtenir des valeurs pour server_version et client_encoding. Les applications sont encouragées à utiliser PQparameterStatus plutôt qu'un code ad-hoc pour trouver ces valeurs. (Notez cependant que pour les connexions pré-3.0, changer client_encoding via SET après le lancement de la connexion ne sera pas reflété par PQparameterStatus). Pour server_version, voir aussi PQserverVersion, qui renvoie l'information dans un format numérique plus facile à comparer.

Si aucune valeur n'est indiquée pour standard_conforming_strings, les applications peuvent considérer qu'elle vaut off, c'est-à-dire que les antislashs sont traités comme des échappements dans les chaînes littérales. De plus, la présence de ce paramètre peut être pris comme une indication que la syntaxe d'échappement de chaîne (E'...') est acceptée.

Bien que le pointeur renvoyé est déclaré const, il pointe en fait vers un stockage mutable associé à la structure PGconn. Il est déconseillé de supposer que le pointeur restera valide pour toutes les requêtes.

Interroge le protocole interface/moteur lors de son utilisation.

int PQprotocolVersion(const PGconn *conn);
       

Les applications peuvent utiliser ceci pour déterminer si certaines fonctionnalités sont supportées. Actuellement, les seules valeurs possible sont 2 (protocole 2.0), 3 (protocole 3.0) ou zéro (mauvaise connexion). La version du protocole ne changera pas après la fin du lancement de la connexion mais il pourrait théoriquement changer lors d'une réinitialisation de la connexion. Le protocole 3.0 sera normalement utilisé lors de la communication avec les serveurs PostgreSQL 7.4 ou ultérieures ; les serveurs antérieurs à la 7.4 supportent uniquement le protocole 2.0 (le protocole 1.0 est obsolète et non supporté par libpq).

Renvoie un entier représentant la version du moteur.

int PQserverVersion(const PGconn *conn);

Les applications peuvent utiliser cette fonction pour déterminer la version du serveur de bases de données où ils sont connectés Le résultat est obtenu en multipliant le numéro de version majeure de la bibliothèque par 10000 et en ajoutant le numéro de version mineure. Par exemple, la version 10.1 renverra 100001, et la version 11.0 renverra 110000. Zéro est renvoyé si la connexion est mauvaise.

Avant la version majeure 10, PostgreSQL utilisait des numéros de version en trois parties, pour lesquelles les deux premières parties représentaient la version majeure. Pour ces versions, PQlibVersion utilise deux chiffres pour chaque partie. Par exemple, la version 9.1.5 renverra 90105, et la version 9.2.0 renverra 90200.

De ce fait, pour déterminer la compatibilité de certaines fonctionnalités, les applications devrait diviser le résultat de PQserverVersion par 100, et non pas par 10000, pour déterminer le numéro de version majeure logique. Dans toutes les versions, seuls les deux derniers chiffres diffèrent entre des versions mineures (versions correctives).

Renvoie le dernier message d'erreur généré par une opération sur la connexion.

char *PQerrorMessage(const PGconn* conn);
       

Pratiquement toutes les fonctions libpq initialiseront un message pour PQerrorMessage en cas d'échec. Notez que, par convention dans libpq, un résultat non vide de PQerrorMessage peut courir sur plusieurs lignes et finira par un retour chariot. L'appelant ne devrait pas libérer directement le résultat. Il sera libéré quand le pointeur PGconn associé sera passé à PQfinish. La chaîne résultante n'est pas supposée rester la même pendant les opérations sur la structure PGconn.

Obtient le descripteur de fichier du socket de la connexion au serveur. Un descripteur valide sera plus grand ou égal à 0 ; un résultat de -1 indique qu'aucune connexion au serveur n'est actuellement ouverte (ceci ne changera pas lors du fonctionnement habituel, mais pourrait changer lors de la mise en place de la connexion ou lors d'une réinitialisation).

int PQsocket(const PGconn *conn);
       

Renvoie l'identifiant du processus (PID) du serveur gérant cette connexion.

int PQbackendPID(const PGconn *conn);
       

Le PID du processus backend est utile pour des raisons de débogage et pour la comparaison avec les messages NOTIFY (qui incluent le PID du processus serveur lançant la notification). Notez que le PID appartient à un processus exécuté sur l'hôte du serveur de bases de données et non pas sur l'hôte local !

Renvoie true (1) si la méthode d'authentification de la connexion nécessite un mot de passe, mais qu'aucun n'est disponible. Renvoie false (0) sinon.

        int PQconnectionNeedsPassword(const PGconn *conn);
       

Cette fonction peut être utilisée après un échec de connexion pour décider s'il faut demander un mot de passe à l'utilisateur.

Renvoie true (1) si la méthode d'authentification de la connexion a utilisé un mot de passe. Renvoie false (0) sinon.

        int PQconnectionUsedPassword(const PGconn *conn);
       

Cette fonction peut être utilisée après une connexion, réussie ou en échec, pour détecter si le serveur demande un mot de passe.

Renvoie true (1) si la connexion utilise SSL, false (0) dans le cas contraire.

int PQsslInUse(const PGconn *conn);
       

Renvoie des informations relatives à SSL à propos de la connexion.

const char *PQsslAttribute(const PGconn *conn, const char *attribute_name);
       

La liste des attributs disponibles varie en fonction de la bibliothèque SSL utilisée, et du type de la connexion. Si un attribut n'est pas disponible, renvoie NULL.

Les attributs suivants sont communément disponibles :

Renvoie un tableau des attributs SSL disponibles. Le tableau est terminé par un pointeur NULL.

const char * const * PQsslAttributeNames(const PGconn *conn);
       

Renvoie un pointeur sur un objet SSL qui est dépendant de l'implémentation et qui décrit la connexion.

void *PQsslStruct(const PGconn *conn, const char *struct_name);
       

La ou les structures disponibles dépendent de l'implémentation SSL utilisée. Pour OpenSSL, il y a une structure, disponible sous le nom "OpenSSL", qui renvoie un pointeur sur la structure OpenSSL SSL. Un exemple de code utilisant cette fonction pourrait être :

 #include <libpq-fe.h>
 #include <openssl/ssl.h>

 ...

     SSL *ssl;

     dbconn = PQconnectdb(...);
     ...

     ssl = PQsslStruct(dbconn, "OpenSSL");
     if (ssl)
     {
         /* utilisez les fonctions OpenSSL pour accéder à ssl */
     }
 

Cette structure peut être utilisée pour vérifier les niveaux de chiffrement, les certificats du serveur, etc. Référez-vous à la documentation d'OpenSSL pour des informations sur cette structure.

Renvoie la structure SSL utilisée dans la connexion, ou NULL si SSL n'est pas utilisé.

void *PQgetssl(const PGconn *conn);
       

Cette fonction est équivalente à PQsslStruct(conn, "OpenSSL"). Elle ne devrait pas être utilisée dans les nouvelles applications, car la structure renvoyée est spécifique à OpenSSL et ne sera pas disponible si une autre implémentation SSL est utilisée. Pour vérifier si une connexion utilise SSL, appelez plutôt PQsslInUse, et, pour plus de détails à propos de la connexion, utilisez PQsslAttribute.