CREATE TYPE typename (
INPUT = input_function
, OUTPUT = output_function
, INTERNALLENGTH = (internallength | VARIABLE)
[ , EXTERNALLENGTH = (externallength | VARIABLE) ]
[ , ELEMENT = element ]
[ , DELIMITER = delimiter ]
[ , DEFAULT = "default" ]
[ , SEND = send_function ]
[ , RECEIVE = receive_function ]
[ , PASSEDBYVALUE ]
)
|
nom du type a créer.
valeur littérale, qui spécifie la longueur interne du nouveau type.
valeur littérale, qui spécifie la longueur externe du nouveau type.
nom de la fonction, créée par CREATE FUNCTION, qui converti la donnée depuis la forme externe vers la forme interne du type.
nom d'une fonction, créée par CREATE FUNCTION, qui convertit la donnée depuis sa forme interne vers une forme correcte à l'affichage.
le type créé est un tableau; spécifie le type des éléments du tableau.
le caractère délimiteur pour le tableau.
le texte par défaut affiché pour indiquer "donnée non présente".
nom d'une fonction, créée par CREATE FUNCTION, qui convertit la donnée de ce type en une forme appropriée pour la transmission à une autre machine.
nom d'une fonction, créée par CREATE FUNCTION, qui convertit la donnée de ce type en une forme appropriée pour la transmission depuis une autre machine vers une forme interne.
CREATE TYPE permet à l'utilisateur d'enregistrer un nouveau type utilisateur avec Postgres pour l'utiliser dans la base. L'utilisateur qui définit un type en devient propriétaire. typename est le nom du nouveau type et doit être unique dans les types définis dans la base.
CREATE TYPE nécessite l'enregistrement de deux fonctions (en utilisant create function) avant de définir le type. La représentation d'un nouveau type base est déterminée par input_function, qui convertit la représentation du type externe en une représentation interne utilisable par les opérateurs et les fonctions définies pour le type. Naturellement, output_function produit la tranformation inverse. Les deux fonctions entrée et sortie doivent être déclarées pour prendre un ou deux arguments de type "opaque".
Les nouveaux types base peuvent être de longueur fixe, auquel cas internallength est un entier positif, ou une longueur variable, dans ce cas Postgres suppose que le nouveau type a le même format que le type fournit par Postgres "text". Pour indiquer qu'un type est de longueur variable, placez internallength à VARIABLE. La représentation externe est spécifiée de façon similaire en utilisant le mot-clé externallength.
Pour indiquer qu'un type est un tableau et pour indiquer qu'un type a des éléments de tableau, indiquez le type d'élément tableau utilisant l'élément mot-clé. Per exemple, pour définir un tableau de d'entiers en 4 octets ("int4"), spécifiez
ELEMENT = int4 |
Pour indiquer le délimiteur à utiliser sur les tableaux de ce type, delimiter peut être placé comme caractère spécifique. Le délimiteur par défaut est la virgule (",").
Une valeur par défaut est optionnellement disponible dans le cas où l'utilisateur désire un comportement spécifique pour signifier "data not present". Spécifiez la valeur par défaut avec le mot-clé DEFAULT.
Les fonctions optionnelles send_function et receive_function sont utilisées quand le programe requerant les services Postgres réside sur une machine différente. Dans ce cas, la machine sur laquelle Postgres tourne peut utiliser un format différent pour la type de celui utilisé sur la machine distante. Dans ce cas il est approprié de convertir les données en une forme standard en envoyant du serveur au client et en convertissant depuis le format standard vers le format spécifique de la machine quand le serveur reçoit la donnée du client. Si ces fonctions ne sont pas spécifiées, alors il est supposé que le format interne du type est acceptable sur toutes les architectures machines relevant. Par exemple, les caractères seuls n'ont pas a être convertis si passed depuis un Sun-4 vers une station DEC, mais plusieurs autres types le font.
Le flag optionnel, PASSEDBYVALUE, indique que les opérateurs et les fonctions qui utilisent ce type seront passés en argument par valeur plus que par référence. Notez que vous ne pouvez pas passer par des types valeur dont la représentation interne est supérieure à 4 octets.
Pour les nouveaux types base, un utilisateur peut définir des opérateurs, des fonctions et des aggrégats en utilisant les fonctionnalités appropriées décrites dans cette section.
Deux fonctions natives généralisées, array-in et array-out, existent pour une création rapide de types tableau de longueur variable. Ces fonctions opérent sur les tableaux de n'importe quel type existant dans Postgres.
Un type Postgres "régulier" peut seulement avoir 8192 octets de longueur. Si vous avez besoin d'un type plus grand, vous devez créer un Large Object Type. L'interface pour ces types est discutée en détail dans la section 7, le large object interface. La longueur d'un type objet long est toujours VARIABLE.
Cette commande crée le type box et alors utilise le type dans une définition de classe :
CREATE TYPE box (INTERNALLENGTH = 8,
INPUT = my_procedure_1, OUTPUT = my_procedure_2);
CREATE TABLE myboxes (id INT4, description box);
|
Cette commande crée un type tableau de longueur variable avec des éléments entiers :
CREATE TYPE int4array (INPUT = array_in, OUTPUT = array_out,
INTERNALLENGTH = VARIABLE, ELEMENT = int4);
CREATE TABLE myarrays (id int4, numbers int4array);
|
Cette commande crée un type objet long et l'utilise dans une définition de lcasse :
CREATE TYPE bigobj (INPUT = lo_filein, OUTPUT = lo_fileout,
INTERNALLENGTH = VARIABLE);
CREATE TABLE big_objs (id int4, obj bigobj);
|