COPY

Guide de l'utilisateur PostgreSQL
Prev		Next

Entrées

BINARY: Change le comportement du formatage des champs, forçant toutes les données à être stockées ou lues comme objet binaire plus que comme texte.
table: nom d'un table existante
WITH OIDS: copie l'objet interne id (OID) unique pour chaque ligne.
filename: Chemin Unix absolu du fichier entrée ou sortie.
stdin: Spécifie que l'entrée provient d'un tube ou d'un terminal.
stdout: Spécifie que la sortie va vers un tube ou un terminal.
delimiter: Caractère qui délimite les champs entrée et sortie.

Description

COPY déplace les données entre les tables Postgres et les fichiers standards Unix. COPY envoie l'instruction à Postgres d'écrire ou de lire vers un fichier. Le fichier doit être directement visible par le serveur et le nom doit être spécifié depuis le point de vue du serveur. Si stdin ou stdout sont spécifiés, les données passeront du client vers le serveur.

Notes

Le mot-clé BINARY forcera toutes les données a être stockées/lues comme objets binaires plus que comme texte. C'est plus rapide que la commande copy normale, mais ce n'est généralement pas portable, et les fichiers générés sont plus gros quoique que ce facteur soit hautement dépendant de la donnée elle-même. Par défaut, un copy texte utilise un caractère tab ("\t") comme délimiteur. Le délimiteur peut aussi être changé en quelque autre caractère avec la phrase USING DELIMITERS. Les caractères dans les zones d'information qui s'avèrent justement apparier le caractère de séparateur seront cités.

Vous devez avoir sélectionné des accès sur une table dont les valeurs sont lues par COPY, et ou insérer ou mettre à jour des accès vers une table dans laquelle les valeurs sont insérées par COPY. Le serveur nécessite aussi les permissions Unix appropriées pour chaque fichier lu ou écrit par COPY.

La phrase-clé USING DELIMITERS spécifie q'un caractère seul sera utilisé par tous les délimiteurs entre les colonnes. Si des caractères multiples sont spécifiés dans la chaîne délimiteur, seul le premier caractère est utilisé.

ne pas confondre COPY avec l'instruction psql \copy.

Formats de fichiers

Format texte

Quand COPY TO est utilisé sans l'option BINARY, le fichier généré aura chaque instance sur une seule ligne, avec chaque colonne (attribute) séparée par le caractère délimiteur. Les caractères délimiteurs intégrés seront précédés par un caractère backslash ("\"). Les valeurs attribut elles-même sont des chaînes générées par la fonction sortie associée avec chaque type attribut. La fonction sortie pour un type n'essaiera pas de générer le caractère backslash ; celui-ci sera généré par COPY lui-même.

Le format actuel pour chaque instance est
<attr1><separator><attr2><separator>...<separator><attrn><newline>
le oid est placé au début de la ligne si WITH OIDS est spécifié.

Si COPY envoie ses résultats vers une sortie standard au lieu d'un fichier, il sera envoyé un backslash ("\") et un point (".") suivi immédiatement par une nouvelle ligne, sur une ligne séparée, quand c'est exécuté. De façon similaire, si COPY lit depuis une entrée standard, il attendra un backslash'"\") et un point (".") suivi par une nouvelle ligne, comme les trois premiers caractères sur une ligne pour noter la fin du fichier. Cependant, COPY terminera (suivi par le backend lui-même) si un vrai EOF est rencontré avant que ce spécial modèle spécial de fin de fichier soit trouvé.

Le caractère backslash a d'autres fonctionnalités. Les attributs NULL sont des sorties comme "\N". Un caractère backslash litéral est une sortie comme deux backslash consécutifs ("\\"). Un caractère tab litéral est représenté comme un backslash et un tab. Un caractère litéral newline est représenté comme un backslash et un newline. Quand des données texte sont chargées non générées par Postgres, vous devrez convertir les caractères backslash ("\") en double-backslashes ("\\") pour être sûr qu'ils sont chargés proprement.

Binary Format

Dans le cas de COPY BINARY, les quatre premiers octets du fichier représente le nombre d'instances du fichier. Si ce nombre est zero, la commande COPY BINARY lira jusqu'à ce que la fin du fichier soit atteinte. D'autre part, il arrêtera la lecture quand ce nombre d'instances a été lu. Supprimant les données dans le fichier qui sera ignoré.

Le format de chaque instance dans le fichier est le suivant. Notez que ce format doit être suivit exactement. Les quantités en entiers 4 octets non-signés sont appelés uint32 dans la table ci-dessous.

Tableau 14-1. Contenu d'un fichier copy binaire

At the start of the file
uint32	number of tuples
For each tuple
uint32	total length of tuple data
uint32	oid (if specified)
uint32	number of null attributes
[uint32,...,uint32]	attribute numbers of attributes, counting from 0
-	<tuple data>

Alignement de donnée binaire

Sur Sun-3s, les attributs 2-octets sont alignés sur deux octets frontière, et tous les attributs plus grands sont alignés sur quatre-octets frontière. Les attributs character sont alignés sur un seul octet frontière. Sur la plupart des autres machines, tous les attributs supérieurs à 1 octet sont alignés sur quatre-octets frontière. Notez que les attributs de longueur variable sont précédés par la longueur attribut ; les tableaux sont simplement contigus aux streams de l'élément type table.

Utilisation

L'exemple suivant copie une table vers la sortie standard, en utilisant une barre verticale ("|") comme délimiteur de champ :

COPY country TO stdout USING DELIMITERS '|';

Pour copier des données depuis un fichier Unix vers une table "country" :

COPY country FROM '/usr1/proj/bray/sql/country_data';

Ici un exemple de donnée appropriée pour copier dans une table depuis stdin (ainsi il a une séquence de terminaison sur la dernière ligne) :

   AF      AFGHANISTAN
   AL      ALBANIA
   DZ      ALGERIA
   ...
   ZM      ZAMBIA
   ZW      ZIMBABWE
   \.

Les mêmes données, sortie en format binaire sur une machine Linux/i586. La donnée est montrée après filtrage à travers l'utilitaire Unix od -c. La table a trois champs ; le premier est char(2) et le second est text. Toutes les lignes ont une valeur null dans le troisième champ. Notez comment le champ char(2) est rempli avecdes nulls de quatre octets et le champ texte est précédé par sa longueur :

   355  \0  \0  \0 027  \0  \0  \0 001  \0  \0  \0 002  \0  \0  \0
   006  \0  \0  \0   A   F  \0  \0 017  \0  \0  \0   A   F   G   H
     A   N   I   S   T   A   N 023  \0  \0  \0 001  \0  \0  \0 002
    \0  \0  \0 006  \0  \0  \0   A   L  \0  \0  \v  \0  \0  \0   A
     L   B   A   N   I   A 023  \0  \0  \0 001  \0  \0  \0 002  \0
    \0  \0 006  \0  \0  \0   D   Z  \0  \0  \v  \0  \0  \0   A   L
     G   E   R   I   A
   ...              \n  \0  \0  \0   Z   A   M   B   I   A 024  \0
    \0  \0 001  \0  \0  \0 002  \0  \0  \0 006  \0  \0  \0   Z   W
    \0  \0  \f  \0  \0  \0   Z   I   M   B   A   B   W   E

Bugs et particularités

COPY neither invokes rules nor acts on column defaults. Il invoque les déclencheurs cependant..

COPY arrête l'opération à la première erreur. Ceci ne conduira pas à des problèmes dans l'éventualité d'un COPY FROM, mais la relation cible, bien sûr, sera partiellement modifiée en un COPY TO. La requête VACUUM sera utilisée pour nettoyer après un copy qui a échoué.

Parce que le répertoire du serveur Postgres n'est pas habituellenemt le même que le répertoire de travail de l'utilisateur, le résultat de la copie vers un fichier foo (sans information complémentaire de chemin) peut produire des résultats non escomptés pour l'utilisateur naïf. Dans ce cas, foo clôturera dans $PGDATA/foo. En général, le nom de chemin complet comme il apparaitrai au serveur de la machine serveur sera utilisé en spécifiant les fichiers à copier.

Les fichiers utilisés comme arguments à COPY doivent être dans ou être accessibles à la machine serveur en étant ou sur le disque local ou sur un système de fichiers réseau.

Quand une connection TCP/IP depuis une machine vers une autre est utilisées, et un fichier cible est spécifié, le fichier cible sera écrit sur la machine où le serveur tourne davantage que sur la machine de l'utilisateur.

Prev	Home	Next
COMMIT	Up	CREATE AGGREGATE