+ "http://www.PostgreSQL.org/docs/view.php?version=current&idoc=1&file=kernel-resources.html">Administration
+ du manuel PostgreSQL pour des informations plus détaillées sur la mémoire partagée et les sémaphores.
+
+
3.5) Comment contrôler les connexions d'autres machines ?
+
+
Par défaut, PostgreSQL n'autorise que les connexions de la machine locale
+ utilisant les sockets de domaine Unix. D'autres machines ne seront pas
+ capables de se connecter sauf si vous configurez tcpip_sockets dans postgresql.conf
+ et activez l'authentification basée sur l'hôte en modifiant le fichier
+ $PGDATA/pg_hba.conf en conséquence. Ceci autorisera les connexions TCP/IP.
+
+
3.6) Comment régler le moteur de la base de données pour de meilleures performances ?
+
+
Des index accéléreront les requêtes. La commande
+ EXPLAIN ANALYZE vous permet de voir comment PostgreSQL traite
+ votre requête et quels index sont utilisés.
+
+
Si vous faites beaucoup d'insertions (instruction INSERT),
+ envisagez de les faire en une fois en utilisant la commande COPY. Ceci
+ est plus rapide que des commandes INSERTS individuelles. Deuxièment,
+ les requêtes qui ne sont pas dans des blocs de transaction BEGIN WORK/COMMIT
+ sont considérés comme étant dans leur propre transaction. Envisagez de faire
+ plusieurs instructions dans un seul bloc de transaction. Ceci réduira la
+ surcharge apportée par les transactions. Aussi, envisagez d'abandonner et
+ de recréer des index lors de grosses modifications de données.
+
+
Il y a plusieurs options d'optimisations. Vous pouvez désactiver
+ fsync() en lançant postmaster avec l'option -o -F.
+ Ceci empêchera les fsync()s d'écrire sur disque après toute
+ transaction.
+
+
Vous pouvez utiliser l'option -B de postmaster pour
+ augmenter le nombre de tampons de mémoire partagée utilisés par les
+ processus serveurs. Si vous fixez ce paramètre trop haut,
+ postmaster ne se lancera pas car vous avez dépassé la limite de
+ votre noyau sur la quantité de mémoire partagée. Chaque tampon fait 8 Ko et
+ le choix par défaut est de 64 tampons.
+
+
Vous pouvez utiliser l'option serveur -S pour augmenter la
+ quantité maximale de mémoire utilisée par les processus serveurs pour des
+ tris temporaires. La valeur de -S est mesuré en kilooctets et le
+ choix par défaut est de 512 (c'est-à-dire 512 Ko).
+
+
Vous pouvez utiliser la commande CLUSTER pour regrouper
+ vos données en tables pour correspondre à un index. Voir la page de manual
+ CLUSTER pour plus de détails.
+
+
3.7) Quelles fonctionalités de déboguage sont disponibles ?
+
+
PostgreSQL a plusieurs fonctionalités qui permettent de recueillir des
+ informations de statut qui peuvent être utile pour des intentions de
+ déboguage.
+
+
D'abord, en lançant configure avec l'option --enable-cassert,
+ beaucoup d'assert()s surveillent le serveur et arrêtent le programme
+ quand quelque chose d'inattendu arrive.
+
+
Postmaster et postgres ont tous deux plusieurs options de
+ déboguage de disponible. D'abord, quand vous lancez postmaster,
+ vérifiez que vous envoyez les sorties standard et d'erreur dans un fichier
+ de traces comme :
+ cd /usr/local/pgsql
+ ./bin/postmaster >server.log 2>&1 &
+
+
+
Ceci va créer un fichier server.log dans le répertoire racine de
+ PostgreSQL. Ce fichier contient des informations utiles sur les problèmes
+ ou erreurs rencontrés par le serveur. Postmaster dispose d'une
+ option -d qui permet de rapporter des informations encore plus
+ détaillées d'être rapportées. L'option -d prend un numéro qui
+ spécifie le niveau de déboguage. Faites attention au fait que des valeurs
+ élévées de niveau de déboguage génerent des fichiers de traces volumineux.
+
+
Si postmaster ne tourne pas, vous pouvez lancer le serveur
+ postgres de la ligne de commande et taper votre requête
+ SQL directement. Ceci est recommandé seulement pour
+ des fonctions de déboguage. Notez qu'un retour chariot termine la requête,
+ pas un point-virgule. Si vous compilez avec les symboles de déboguage, vous
+ pouvez utiliser un débogueur pour voir ce qui se passe. Parce que le serveur
+ n'a pas été lancé par postmaster, il ne tourne pas dans un environnement
+ identique et les problèmes d'interaction de verrouillage/serveur ne peuvent
+ être dupliqués.
+
+
Si postmaster est en train de tourner, lancez psql dans
+ une fenêtre puis trouvez le PID du processus postgres
+ utilisé par psql. Utilisez un débogueur pour l'attacher au
+ PID postgres. Vous pouvez mettre un point d'arrêt
+ dans le débogueur et envoyez des requêtes de psql. Si vous déboguez
+ le démarrage de postgres, vous pouvez mettre PGOPTIONS="-W n", puis
+ lancez psql. Ceci va retarder le démarrage de n secondes
+ pour que vous puissiez attacher un débogueur au processus, fixer des points
+ d'arrêt et continuer la séquence de démarrage.
+
+
Le programme postgres a les options -s, -A et -t
+ qui peuvent être utile pour des mesures de déboguage et de performance.
+
+
Vous pouvez compiler avec les options de performance pour voir quelles
+ fonctions prennent du temps d'exécution. Les fichiers de gestion du serveur
+ seront déposés dans le répertoire pgsql/data/base/nom_db. Les
+ fichiers de gestion clients seront mis dans le répertoire actuel du client.
+ Linux requiert une compilation avec -DLINUX_PROFILE pour une
+ meilleure gestion.
+
+
3.8) Pourquoi est-ce que j'obtiens des messages Sorry, too many clients quand je me connecte ?
+
+
Vous pouvez augmenter la limite de postmaster sur le nombre de
+ processus serveur concurrents qu'il peut lancer.
+
+
La limite par défaut est de 32 processus. Vous pouvez l'augmenter en
+ relançant postmaster avec une valeur -N appropriée ou
+ en modifiant postgresql.conf.
+
+
Tenez compte du fait que si vous fixez -N plus grand que 32, vous
+ devez aussi augmenter -B au-dela de sa valeur par défaut 64 ;
+ -B doit valoir au moins deux fois -N et probablement plus pour
+ une meilleure performance. Pour de grand nombres de processus serveurs vous
+ aurez probablement aussi augmenter plusieurs parametres de configuration du
+ noyau Unix. Les choses a vérifier incluent la taille maximale des blocs de
+ mémoire partagée, SHMMAX ; le nombre maximal de
+ sémaphores, SEMMNS et SEMMNI ; le
+ nombre maximal de processus, NPROC ; le nombre maximal
+ de processus par utilisateur, MAXUPRC ; et le nombre
+ maximal de fichiers ouverts, NFILE et NINODE.
+ La raison pour laquelle PostgreSQL a une limite sur le nombre de processus
+ serveurs autorisés est pour que votre système ne tombe pas à court de
+ ressources.
+
+
3.9) Que contient le répertoire pgsql_tmp ?
+
+
Ce répertoire contient des fichiers temporaires générés par le moteur de
+ requête. Par exemple, si un tri doit être fait pour satisfaire un
+ ORDER BY et que ce tri requiert plus de place que le paramètre
+ -S du serveur n'autorise, alors des fichiers temporaires seront créés
+ pour contenir les données nécessaires.
+
+
Les fichiers temporaires sont d'habitude effacés automatiquement mais
+ peuvent rester si un serveur s'arrête brutalement pendant un tri. Un arrêt
+ et un redémarrage de postmaster effacera les fichiers dans ces
+ répertoires.
+
+
3.10) Pourquoi est-ce que j'ai besoin de faire une
+ sauvegarde des bases et de restaurer pour mettre a jour les versions de
+ PostgreSQL ?
+
+
L'équipe PostgreSQL ne fait que des changements mineurs entre des
+ versions mineurs, donc mettre à jour de 7.2 vers 7.2.1 ne nécessitera pas
+ de sauvegarde et de restauration. Par contre, les sorties majeures
+ (c'est-à-dire de 7.2 vers 7.3) changent souvent le format interne des tables
+ systèmes et des fichiers de données. Ces modifications sont souvent
+ complexes alors nous ne gardons pas de compatibilité descendante pour les
+ fichiers de données. Une sauvegarde exportera les données dans un format
+ générique qui peut ensuite être chargé dans le nouveau format interne.
+
+
Dans les sorties où le format sur disque ne change pas, le script
+ pg_upgrade peut être utilisé pour mettre à jour sans
+ sauvegarde/restauration. Les notes de sorties précisent si pg_upgrade
+ est disponible pour la sortie.
+
+
3.11) Quels matériels dois-je utiliser ?
+
+
Comme le matériel PC est compatible en grosse partie, les gens ont
+ tendance à croire que tous les matériels PC sont de même qualité. Ce n'est
+ pas le cas. La RAM ECC, le SCSI et les cartes-mère de qualité sont plus
+ fiables et ont de meilleurs performances qu'un matériel moins coûteux.
+ PostgreSQL fonctionnera sur à peu près tout matériel mais si la fiabilité et
+ la performance sont importantes pour vous, il est rusé de bien considérer
+ les options matérielles. Nos listes de diffusion peuvent être utilisées pour
+ discuter des options matériels.
+
+
+
+
Questions fonctionnelles
+
+
4.1) Quelle est la différence entre curseur binaire
+ et curseur normal ?
+
+
Voir la page DECLARE du manuel pour une description.
+
+
4.2) Comment faire un SELECT seulement
+ sur les premières lignes d'une requête ? Sur une ligne aléatoire ?
+
+
Voir la page FETCH du manuel ou utiliser
+ SELECT ... LIMIT....
+
+
Il se peut que l'intégralité de la requête doive être évaluée,
+ même si vous voulez seulement les premières lignes. Envisagez
+ d'utiliser une requête avec une clause ORDER
+ BY. S'il existe un index correspondant à l'ORDER
+ BY, PostgreSQL peut n'évaluer que les premières lignes, sinon
+ l'intégralité de la requête peut être évaluée, jusqu'à générer les lignes
+ désirées.
+
+
Pour faire un SELECT sur une ligne aléatoire :
+ SELECT colonne
+ FROM table
+ ORDER BY random()
+ LIMIT 1;
+
+
+
4.3) Comment obtenir une liste des tables ou
+ d'autres objets que je vois dans psql ?
+
+
Utilisez la commande \dt pour voir les tables dans psql. Pour
+ une liste complète de commandes à l'intérieur de psql, vous pouvez utiliser
+ \?. Autrement, vous pouvez lire le code source de psql dans le fichier
+ pgsql/src/bin/psql/describe.c. Il contient des commandes
+ SQL qui génèrent le contenu des commandes anti-slash de
+ psql. Vous pouvez aussi lancer psql avec l'option
+ -E, afin qu'il imprime les requêtes qu'il utilise pour exécuter
+ les commandes que vous lui passez. PostgreSQL fournit aussi une interface
+ d'informations sur le schéma compatible avec SQLi que vous pouvez
+ interroger des informations sur la base de données.
+
+
4.4) Comment supprime-t-on une colonne d'une table,
+ ou comment change-t-on son type de données ?
+
+
La fonction DROP COLUMN a été ajoutée dans la version 7.3
+ avec ALTER TABLE DROP COLUMN. Pour les versions précédentes,
+ vous pouvez faire :
+ BEGIN;
+ LOCK TABLE ancienne_table;
+ SELECT ... -- sélectionnez toutes les colonnes sauf celle à supprimer
+ INTO TABLE nouvelle_table
+ FROM ancienne_table;
+ DROP TABLE ancienne_table;
+ ALTER TABLE nouvelle_table RENAME TO ancienne_table;
+ COMMIT;
+
+
+
Pour changer le type de données d'une colonne, faites :
+
+ BEGIN;
+ ALTER TABLE table ADD COLUMN nouvelle_colonne nouveau_type_de_donnees;
+ UPDATE table SET nouvelle_colonne = CAST(ancienne_colonne AS nouveau_type_de_donnees);
+ ALTER TABLE table DROP COLUMN ancienne_colonne;
+ COMMIT;
+
+
+
Après, vous pouvez faire VACUUM FULL tab pour récupérer l'espace
+ disque utilisé par les lignes expirées.
+
+
4.5) Quelle est la taille maximale pour une ligne,
+ une table, une base de données ?
+
+ Taille maximum pour une base de données illimitée (il existe des bases de 32 To)
+ Taille maximum pour une table 32 To
+ Taille maximum pour une ligne 1,6 To
+ Taille maximum pour un champ 1 Go
+ Nombre maximum de lignes dans une table illimité
+ Nombre maximum de colonnes dans une table 250-1600, selon le type de colonnes
+ Nombre maximum d'index sur une table illimité
+
+
+
Bien sûr, ces valeurs ne sont pas vraiment illimitée, elles sont limitées
+ par l'espace disque disponible, ainsi que par l'espace de mémoire et de swap.
+ Les performances peuvent se dégrader si ces valeurs sont inhabituellement
+ grandes.
+
+
La taille maximum des tables (32 To) ne nécessite pas que le système
+ d'exploitation supporte les grands fichiers. Les grandes tables sont stockées
+ sous forme de fichiers multiples de 1 Go, donc les limites de taille du
+ système de fichier ne sont pas importantes.
+
+
La taille maximum des tables et le nombre maximum de colonnes peuvent
+ être quadriplés, si la taille des blocs par défaut est augmentée à 32 Ko.
+
+
4.6) Combien d'espace disque faut-il pour stocker
+ les données d'un fichier texte typique ?
+
+
Une base de données PostgreSQL peut utiliser jusqu'à cinq fois
+ l'espace nécessaire pour stocker les données d'un fichier texte.
+
+
A titre d'exemple, considérez un fichier de 100 000 lignes, comportant
+ un entier et une chaîne de description sur chaque ligne. Supposons que la
+ chaîne soit longue en moyenne de 20 octets. Le fichier texte serait de 2,8 Mo.
+ La taille du fichier d'une base de données PostgreSQL peut être
+ estimée à 6,4 Mo :
+ 36 octets: chaque ligne (approximation)
+ 24 octets: un champ 'entier' et un champ 'texte'
+ + 4 octets: pointeur vers le tuple sur la page
+ ----------------------------------------
+ 64 octets par ligne
+
+ La taille des pages de données dans PostgreSQL est de 8192 octets (8 KO), donc :
+
+ 8192 octets par page
+ ---------------------- = 128 lignes par page de base de données (arrondi à l'entier inférieur)
+ 64 octets par ligne
+
+ 100000 lignes de données
+ ------------------------- = 782 pages de base de données (arrondi à l'entier supérieur)
+ 128 lignes par page
+
+782 pages de base de données * 8192 octets par page = 6 406 144 octets (6,4 Mo)
+
+
+
Les index utilisent moins d'espace, mais ils contiennent les données indexées,
+ ils peuvent donc également être grands.
+
+
Les NULL sont stockés sous forme de bitmap, aussi
+ utilisent-ils très peu d'espace.
+
+
4.7) Comment puis-je savoir quels index, tables,
+ bases de données et utilisateurs sont définis ?
+
+
psql dispose de plusieurs commandes commençant par un anti-slash
+ pour retrouver ces informations. Utilisez \? pour les connaître. Il existe
+ aussi des tables systèmes, qui commencent par pg_ et qui les
+ décrivent également. Aussi, psql -l liste toutes les bases de
+ données.
+
+
Essayez également le fichier pgsql/src/tutorial/syscat.source. Il
+ illustre un grand nombre de commandes SELECT nécessaires pour
+ récupérer l'information des tables système de la base de données.
+
+
4.8) Mes requêtes sont lentes ou ne font pas usage
+ des index. Pourquoi ?
+
+
Les index ne sont pas automatiquement utilisés par chaque requête. Ils
+ sont utilisés uniquement si la table est plus grande qu'une certaine taille,
+ et si la requête sélectionne seulement un faible pourcentage des lignes de la
+ table. Ceci est dû au fait qu'un accès disque aléatoire causé par un parcours
+ d'index peut être plus lent qu'une simple lecture de la table, ou parcours
+ séquentiel
+
+
Pour déterminer si un index devrait être utilisé, PostgreSQL a besoin
+ des statistiques de la table. Ces statistiques sont collectées en lançant
+ VACUUM ANALYZE ou simplement ANALYZE.
+ Avec les statistiques, l'optimiseur sait combien de lignes se trouvent
+ dans la table et peut mieux déterminer s'il faut utiliser l'index.
+ Les statistiques sont également utiles pour déterminer l'ordre optimal
+ des opérations de jointure. La collecte des statistiques devrait être
+ effectuée régulièrement lorsque le contenu de la table change.
+
+
Les index ne sont normalement pas utilisés pour les clauses ORDER BY
+ ou pour les jointures. Un parcours séquentiel suivi d'un tri explicite est
+ habituellement plus rapide qu'un parcours d'index pour une table importante.
+ Toutefois, LIMIT combiné avec ORDER BY
+ utilisera souvent un index parce que seulement une petite partie de la table est
+ renvoyée. En fait, bien que MAX() et MIN() n'utilisent pas les index,
+ il est possible de retrouver ces valeurs en utilisant un index avec
+ ORDER BY et LIMIT :
+
+ SELECT colonne
+ FROM table
+ ORDER BY colonne [ DESC ]
+ LIMIT 1;
+
+
+
Si vous pensez que l'optimiseur choisit par erreur un parcours sequentiel,
+ utilisez SET enable_seqscan TO 'off'
et
+ lancez des tests pour voir si le parcours d'index est effectivement plus rapide.
+
+
Lorsque vous utilisez des caractères joker tels que LIKE ou
+ ~, les index peuvent seulement être utilisés dans certaines circonstances :
+
Le début de la chaîne de recherche doit être ancré au départ de la chaîne, c'est-à-dire
+
Les modèles pour LIKE ne doivent pas commencer par %.
+
Les modèles d'expression régulière pour ~ doivent commencer par
+ ^.
+
+
La chaîne de recherche ne peut pas commencer par une classe de caractères, c'est-à-dire
+ [a-e].
+
Les recherches sans casse comme ILIKE et
+ ~* n'utilisent pas les index. Utilisez plutôt les index fonctionnels,
+ décrit dans la section
4.12.
+
La locale C par défaut doit être utilisée lors de
+ initdb.
+
+
+
4.9) Comment puis-je savoir si l'optimiseur évalue
+ mes requêtes ?
+
+
Voir la page EXPLAIN du manuel.
+
+
4.10) Qu'est-ce qu'un index R-tree ?
+
+
Un index R-tree est utilisé pour l'indexation des données spatiales. Un
+ index de hachage ne permet pas les recherches par plage. Un index B-tree peut
+ seulement faire des recherches sur une dimension. Les index R-tree
+ peuvent traiter des données multi-dimensionnelles. Par exemple, si un index
+ R-tree peut être construit sur un attribut de type point,
+ le système peut plus efficacement gérer les requêtes du type
+ "Sélection de tous les points d'un rectangle".
+
+
L'article de référence qui décrit le système R-tree original est :
+
+
Guttman, A. "R-trees: A Dynamic Index Structure for Spatial
+ Searching." Proceedings of the 1984 ACM SIGMOD Int'l Conf on Mgmt
+ of Data, 45-57.
+
+
Vous pouvez également trouver ce papier dans le livre de Stonebraker
+ "Readings in Database Systems".
+
+
Les index R-tree intégrés peuvent prendre en charge les polygônes et les boîtes.
+ En théorie, les R-trees peuvent être étendus à un plus grand nombre de dimensions.
+ En pratique, l'extension des R-trees requiert pas mal de travail et nous
+ n'avons pour le moment aucune documentation sur la façon de procéder.
+
+
4.11) Qu'est-ce que l'optimiseur génétique de
+ requêtes ?
+
+
Le module GEQO (acronyme de GEnetic Query
+ Optimizer) accélère l'optimisation des requêtes lors de jointures de
+ nombreuses tables par un algorithme génétique (GA). Il permet la
+ gestion des grosses requêtes de jointures en utilisant une recherche non
+ exhaustive.
+
+
4.12) Comment puis-je réaliser des recherches sur des
+ expressions rationnelles ainsi que des recherches non sensibles à la
+ casse ? Comment puis-je utiliser un index lors de recherches non
+ sensibles à la casse ?
+
+
L'opérateur ~ réalise des recherches d'expressions rationnelles
+ et ~* le fait sans tenir compte de la casse. La variante de
+ LIKE non sensible à la casse est
+ ILIKE.
+
+
Des comparaisons d'égalité non sensibles à la casse sont habituellement
+ exprimées de cette façon :
+ SELECT *
+ FROM table
+ WHERE lower(colonne) = 'abc';
+
+
+
Ceci n'utilisera pas un index standard. Néanmoins, si vous créez un index
+ fonctionnel, celui-ci sera utilisé :
+ CREATE INDEX tableindex ON table (lower(colonne));
+
+
+
4.13) Comment puis-je détecter si un champ est
+ NULL dans une requête ?
+
+
Il vous suffit de tester la colonne avec IS NULL ou IS
+ NOT NULL.
+
+
4.14) Quelle sont les différences entre les nombreux
+ types de caractères ?
+Type Nom interne Notes
+--------------------------------------------------
+VARCHAR(n) varchar n spécifie la taille maximum, sans remplissage
+CHAR(n) bpchar des espaces sont ajoutés pour obtenir la
+ longueur fixe spécifiée
+TEXT text pas de limite supérieure pour la taille
+BYTEA bytea tableau d'octets (accepte les octets nuls)
+"char" char un caractère
+
+
+
Vous verrez le nom interne en examinant les catalogues système et dans
+ quelques messages d'erreur.
+
+
Les quatres premiers types du dessus sont des types "varlena"
+ (c'est-à-dire que les quatre premiers octets correspondent à la taille,
+ suivi des données). Donc, l'espace réellement utilisé est légèrement plus
+ grand que la taille déclarée. Néanmoins, ces types de données sont aussi
+ sujet à la compression ou à un enregistrement en dehors de la table avec
+ TOAST, donc l'espace occupé sur disque pourrait aussi être
+ moindre que ce qu'on pourrait attendre.
+
+
VARCHAR(n) est bien mieux pour enregistrer des chaînes de
+ longueurs variables tout en limitant la taille de cette chaîne.
+ TEXT est utile pour les chaînes de longueur illimitée, avec
+ malgré tout un maximum de 1 Go.
+
+
CHAR(n) est intéressant pour stocker des chaînes de taille
+ identique. CHAR(n) complète avec des espaces pour arriver à
+ la taille spécifiée alors que VARCHAR(n) n'enregistre que les
+ caractères donnés. BYTEA sert à stocker des données binaires,
+ particulièrement les données incluant des octets NULL. Tous
+ les types décrits ici ont des performances similaires.
+
+
4.15.1) Comment puis-je créer un champ série,
+ c'est-à-dire s'incrémentant automatiquement ?
+
+
PostgreSQL supporte un type de données SERIAL. Il crée
+ automatiquement une séquence. Par exemple,
+ ceci :
+ CREATE TABLE personne (
+ id SERIAL,
+ nom TEXT
+ );
+
+
+ est automatiquement traduit en ceci :
+ CREATE SEQUENCE personne_id_seq;
+ CREATE TABLE personne (
+ id INT4 NOT NULL DEFAULT nextval('personne_id_seq'),
+ nom TEXT
+ );
+
+
+ Voir la page man de create_sequence pour plus d'informations
+ sur les séquences. Vous pouvez aussi utiliser le champ OID de chaque
+ ligne comme valeur unique. Néanmoins, si vous avez besoin de sauvegarder
+ puis recharger la base de données, vous devrez utiliser l'option
+ -o ou l'option COPY WITH OIDS de
+ pg_dump pour conserver les OIDs.
+
+
4.15.2) Comment puis-je obtenir la valeur d'un
+ SERIAL suite à une insertion ?
+
+
Une approche pour récupérer la prochaine valeur SERIAL à
+ partir de l'objet séquence est d'utiliser la fonction nextval()
+ avant l'insertion et de l'insérer ensuite explicitement. En utilisant
+ la table d'exemple de la section
4.15.1, un exemple
+ dans un pseudo-langage ressemblerait à ceci :
+ nouvelle_id = execute("SELECT nextval('personne_id_seq')");
+ execute("INSERT INTO personne (id, nom) VALUES (nouvelle_id, 'Blaise Pascal')");
+
+
+ Vous pourriez ensuite utiliser la nouvelle valeur stockée dans
+ nouvelle_id
avec d'autres requêtes (c'est-à-dire en tant que
+ clé étrangère de la table personne
). Notez que le nom de la
+ SEQUENCE automatiquement créée sera
+ <table>_<colonneserial>_seq, où
+ table et colonneserial sont les noms respectifs de votre table
+ et de votre colonne SERIAL.
+
+
Autrement, vous pouvez récupérer la valeur SERIAL affectée
+ avec la fonction currval() après qu'elle ait été insérée par
+ défaut, c'est-à-dire,
+ execute("INSERT INTO personne (nom) VALUES ('Blaise Pascal')");
+ nouvelle_id = execute("SELECT currval('personne_id_seq')");
+
+
+ Enfin, vous pouvez utiliser l'
OID renvoyé
+ par l'instruction INSERT pour récupérer la valeur par défaut
+ bien que cela soit l'appoche la moins portable et la valeur de l'OID se
+ réinitialisera aux environs de quatre milliards. En Perl, avec DBI et le
+ module DBD:Pg d'Edmund Mergl, l'ancienne valeur est disponible via
+ $sth->{pg_oid_status} après un $sth->execute().
+
+
4.15.3) Est-ce que currval() et
+ nextval() n'amènent pas des problèmes lorsque plusieurs utilisateurs
+ les lancent en même temps ?
+
+
Non. currval() renvoie la valeur actuelle affectée par votre
+ processus, et non pas par tous les utilisateurs.
+
+
4.15.4) Pourquoi mes numéros de séquences ne sont pas
+ ré-utilisés lors d'une annulation de transaction ? Pourquoi
+ existe-t'il des trous dans la numérotation de ma colonne séquentielle
+ (SERIAL) ?
+
+
Pour améliorer les accès concurrents, les valeurs de séquences sont
+ données aux transactions qui en ont besoin et ne sont pas bloquées jusqu'à
+ la fin de la transaction. Ceci crée des trous dans le numérotage pour les
+ transactions annulées.
+
+
4.16) Qu'est-ce qu'un OID ?
+ Qu'est-ce qu'un TID ?
+
+
Les OID sont la réponse de PostgreSQL aux identifiants de
+ lignes uniques. Chaque ligne créée dans PostgreSQL obtient un
+ OID unique. Tous les OID générés pendant
+ initdb sont inférieurs à 16384 (voir include/access/transam.h).
+ Tous les OID créés par un utilisateur sont supérieurs ou
+ égaux à ceci. Par défaut, tous ces OID sont uniques non
+ seulement dans une table ou une base mais unique à l'intérieur d'une
+ installation PostgreSQL entière.
+
+
PostgreSQL utilise les OID dans ses tables système interne
+ pour lier les lignes entre tables. Ces OID peuvent être
+ utilisés pour identifier des lignes utilisateurs spécifiques et utilisés dans
+ des jointures. Il est recommandé que vous utilisiez le type de colonne
+ OID pour stocker des valeurs OID.
+ Vous pouvez créer un index sur le champ OID pour un accès
+ plus rapide.
+
+
Les OID sont attribués pour toute ligne d'un endroit
+ central qui est utilisé par toutes les bases de données. Si vous voulez
+ changer l'OID en quelque chose d'autre ou si vous voulez
+ faire une copie de la table avec les OID originaux, il
+ n'y a pas de raisons pour ne pas le faire :
+ CREATE TABLE nouvelle_table (macolonne int);
+ SELECT oid AS ancienne_oid, macolonne INTO table_temporaire FROM ancienne_table;
+ COPY table_temporaire FROM '/tmp/tablepg';
+ COPY nouvelle_table WITH OIDS FROM '/tmp/tablepg';
+ DROP TABLE table_temporaire;
+
+
+
Les OID sont stockés en tant qu'entiers de quatre octets
+ et déborderont à quatre milliards. Personne n'a jamais rapporté un tel cas
+ et nous avons prévu de retirer la limite avant que cela ne se produise.
+
+
Les TIDs sont utilisés pour identifier des lignes
+ physiques spécifiques avec des valeurs de bloc et décalage. Les
+ TID changent après que les lignes aient été modifiés ou
+ rechargés. Ils sont utilisés par des entrées d'index pour pointer vers des
+ lignes physiques.
+
+
4.17) A quoi correspond certains termes utilisés avec
+ PostgreSQL ?
+
+
Une partie du code source et de l'ancienne documentation utilisent des
+ termes dont l'usage est plus commun. Voici quelques exemples :
+
+
table, relation, classe
+
ligne (row), enregistrement (record), tuple
+
colonne (column), champ (field), attribut
+
récupère, sélectionne (select)
+
remplace (replace), met à jour (update)
+
ajoute (append), insère (insert)
+
OID, valeur séquentielle (serial value)
+
portal, curseur
+
range variable, table name, table alias
+
+
+
Une liste des termes généraux pour le domaine des bases de données est