Clé primaire composite postgres
Syntaxe de la clé primaire composite dans PostgreSQL
Avant de passer directement à la mise en œuvre du concept composite de clé primaire, nous devons connaître la syntaxe pour faire de 2 attributs ou plus une clé primaire dans le tableau. Ainsi, une clé primaire composite est déclarée comme une primaire normale est déclarée lorsque nous créons un tableau. La syntaxe pour la clé primaire composite est décrite ci-dessous, ainsi que ses caractéristiques ou noms de colonnes:
>> Créer la table Name_OF_TABLE(Column_1 DataType,
Column_2 DataType,
… ,
Column_n DataType
Clé primaire (Column_1, Column_2));
Dans cette requête, nous initialisons un tableau avec plusieurs colonnes, et au lieu d'une initialisation de clé primaire unique en ligne pour les colonnes, nous les initialisons séparément après avoir défini le nom de la colonne et le type de données de la colonne. Nous utilisons le mot-clé «clé primaire» avec un support dans lequel nous écrivons les noms des colonnes séparés avec des virgules pour les spécifier comme une clé primaire composite.
Initialisation d'une clé primaire composite dans PostgreSQL
Comme la syntaxe nous est familière maintenant, nous pouvons consulter quelques exemples pour créer une table avec plusieurs clés principales. Alors d'abord, nous ouvrirons notre éditeur de requête et créerons une table.
>> créer un employé de table1 (e_id int,
e_type int,
e_name varchar,
e_sal int);
Maintenant, nous pouvons créer une table à partir de cette requête, mais il y a un problème dans ce tableau car aucune colonne n'a été spécifiée pour être une clé principale. Dans ce tableau, il peut y avoir plus d'une clé primaire selon les besoins, comme si le salaire doit être ajouté avec des bonus à certains employés avec certains types et noms, donc ils doivent tous être une clé principale. Et si nous initialisons chacun d'eux comme une clé primaire séparément? Voyons comment cela se passe lorsque nous jouons cela dans PostgreSQL.
Créer un employé de table1 (E_ID int clé primaire,
E_TYPE int clé primaire,
e_name varchar,
e_sal int);
La sortie est attachée dans l'image annexée.
Comme la sortie suggère que nous ne pouvons pas créer plus d'une clé principale dans nos tableaux si nous utilisons la méthode à une ligne. Cette méthode n'est pas autorisée dans l'environnement PostgreSQL et ne peut être utilisée que lorsque nous devons déclarer une seule colonne comme clé primaire. Alors maintenant, nous examinerons la bonne méthode pour déclarer plus d'une clé principale dans un tableau de PostgreSQL.
Déclarer deux colonnes comme la clé principale
Dans cette situation, nous ferons deux colonnes de la table pour être des clés principales en même temps. Nous ferons de la colonne ID une clé primaire et le type de colonne d'employée une clé principale dans notre tableau. Nous devons construire cette requête comme suit pour qu'il fonctionne avec succès:
>> créer un employé de table1 (e_id int,
e_type int,
e_name varchar,
e_sal int,
Clé primaire (e_id, e_type)
));
La sortie est attachée dans l'image annexée.
Comme vous pouvez le voir que la sortie suggère que le tableau a été créé avec succès, et nous pouvons l'utiliser pour insérer des valeurs. Maintenant, vérifions cela dans notre environnement Postgres.
>> Insérer dans les valeurs de l'employee1 (011,1, «Josh», 10000),(021,1, «John», 18800),
(031,1, «James», 17000),
(041,2, «Harry», 13000),
(051,2, 'Alex', 14000),
(061,2, «Ron», 15000);
Sélectionner * chez Employee1;
La sortie est attachée dans l'image annexée.
Comme vous pouvez le voir, nous avons réussi une table et des valeurs insérées pendant que nous avions deux clés primaires affectées aux colonnes de la table. Ainsi, dans ce tableau, les clés principales sont «e_id» et «e_type», et nous les avons définis comme des attributs uniques pour le tableau nommé «Employee1».
Déclarer trois colonnes comme clé primaire
Dans cette situation, nous ferons trois colonnes de la table pour devenir des clés primaires en même temps. Nous ferons de la colonne ID une clé principale, le nom de l'employé sera défini comme clé principale, ainsi que le type de colonne d'employée pour être une clé principale dans notre tableau. Pour faire en sorte que cette requête s'exécute avec succès, nous devrons le rassembler comme ceci:
>> créer un employé de table1 (e_id int,
e_type int,
e_name varchar,
e_sal int,
Clé primaire (E_ID, E_TYPE, E_NAME)
));
La sortie est attachée dans l'image annexée.
Comme vous pouvez le voir que la sortie suggère que le tableau a été créé avec succès, et nous pouvons l'utiliser pour insérer des valeurs. Maintenant, vérifions si l'insertion est applicable dans notre environnement Postgres ou non.
Insérer dans les valeurs de l'employé1 (011,1, «James», 10000),(041,2, «Harry», 13000),
(061,2, «Ron», 15000),
(031,1, «James», 17000),
(051,2, 'Alex', 14000),
(021,1, «John», 18800);
Sélectionner * chez Employee1;
La sortie est attachée dans l'image annexée.
Comme vous pouvez le voir, nous avons réussi à créer un tableau et à y saisir des données tout en attribuant trois clés principales aux colonnes de la table. Ainsi, dans ce tableau, les clés principales sont «e id», «type e» et «nom e», et nous les avons désignés comme un attribut unique pour le tableau «Employee1».
Déclarer toutes les colonnes comme clé primaire
Dans cette situation, nous ferons des quatre colonnes de la table pour être des clés principales en même temps. Pour que cette requête fonctionne avec succès, nous devons écrire comme celle-ci comme indiqué ci-dessous:
Créer un employé de table1 (e_id int,
e_type int,
e_name varchar,
e_sal int,
Clé primaire (E_ID, E_TYPE, E_NAME, E_SAL)
));
La sortie est attachée dans l'image annexée.
Comme vous pouvez le voir, le résultat indique que le tableau a été créé avec succès, et nous pouvons maintenant l'utiliser pour insérer des valeurs. Voyons maintenant si l'insertion fonctionne dans notre environnement Postgres.
>> Insérer dans les valeurs de l'employee1 (011,1, 'Jacob', 8000),(051,2, «Alexander», 1400),
(041,2, «Harry», 100),
(031,1, «Jake», 17000),
(061,2, «ray», 3500),
(021,1, «Johnathan», 18800);
Sélectionner * chez Employee1;
La sortie est attachée dans l'image annexée.
Comme vous pouvez le voir, nous avons créé une table, les avons remplies de données et attribué quatre clés principales aux colonnes de la table. Les clés principales de ce tableau sont «e_id», «e_type», «e_name» et «e_sal». Ils ont été déclarés comme un attribut unique pour la table «Employee1».
Nous avons conclu que PostgreSQL nous permet d'avoir plus d'une clé principale dans notre tableau. Nous pouvons le faire évoluer jusqu'à autant de colonnes que possible en utilisant la fonction de clé primaire composite ou même attribuer le caractère unique de la clé primaire à toutes les colonnes du tableau.
Conclusion
Dans cet article, nous avons appris le concept de clé primaire composite dans PostgreSQL. Ainsi, si nous contrevenons à une situation dans laquelle nous devons déclarer plus d'une clé primaire, nous pouvons utiliser la fonction composite de clé primaire pour cette situation à l'aide de cet article. La syntaxe de la déclaration composite de clé primaire a également été discutée en détail dans Postgres, car tous les aspects de la fonction ont été discutés en partie. Ensuite, nous avons également mis en œuvre ce concept dans l'environnement postgresql. La bonne façon de déclarer deux, trois, voire plus de 3 clés primaires dans une seule table dans PostgreSQL est en utilisant la fonction de clé primaire composite.