Postgres grand objet

Les grands objets (lobs) sont les collections de types de données qui sont créées pour contenir une grande quantité de données jusqu'à une taille maximale qui varie de 8 téraoctets à 128 téraoctets. Cela dépend principalement de la configuration d'une base de données.

Pourquoi les grands objets sont utilisés dans PostgreSQL

Nous expliquerons différents types de données adaptées aux grands objets et leur but de création.

• Données structurées: Ceci est un type simple de données structurées et peut être créée dans un tableau simple.
• Données structurées complexes: Ce sont des structures complexes et sont créées pour gérer les caractéristiques de la relation d'objet de la base de données Oracle comme les collections et les références.
• Données non structurées: Ces types de données ne sont pas interprétés par la base de données et ces types de données ne sont pas divisés en structures logiques plus petites.

Syntaxe

# Create Table Table_name (name_of_column1 data_type, name_of_column2 data_type, name_of_columnn bytea);

Une table pour un grand objet est créée avec le type de données d'une colonne spécifique ayant une bytea ou un blob pour stocker les valeurs d'un grand objet comme des images ou des vidéos.

Mise en œuvre

Nous allons créer un tableau avec le type de données de BLOB dans une colonne, tandis que d'autres colonnes ont des types de données entiers et varchar. Mais lors de l'exécution d'une requête, cela provoque une erreur en affichant que le type «blob» n'existe pas.

>> Créer la table TBL_BLOB (TBL_BLOB BLOB, ID INTEGER, NAME VARCHAR (10), Adresse VARCHAR (10));

Nous allons créer à nouveau les mêmes attributs de table en ayant la première colonne avec le type de données de 'bytea'. Il s'agit également d'un type de variable de données de type blob. En utilisant cela, nous pouvons restaurer les données du type binaire dans PostgreSQL.

>> Créer une table TBL_BLOB (TBL_BLOB BYTEA, ID INTEGER, NAME VARCHAR (10), Adresse VARCHAR (10));

Cela a été fait pour montrer la différence dans l'utilisation de Blob et Bytea. Le plus souvent, Blob n'est pas compatible avec certaines versions de PostgreSQL; C'est pourquoi nous utilisons Bytea dans la commande.

Un nouveau tableau d'échantillons sera à nouveau créé pour tester l'utilisation du grand objet. Un tableau nommé TBL_BLOB1 est créé.

>> Créer la table TBL_BLOB1 (TBL_BLOB BYTEA, ID INTEGER, NOM VARCHAR (10), Adresse VARCHAR (10), classe

varchar (10)); [/ cc]

Après avoir créé la table, nous verrons maintenant la description de la table pour noter le type de stockage et les types de colonnes.

>> \ d + tbl_blol1;

Vous pouvez voir dans l'image ci-dessus que les noms de colonne et le type de données sont affichés. La méthode utilisée pour accéder à cette description est le tri de tas. Pour expliquer l'utilisation de grands objets dans plus d'une colonne, nous créerons à nouveau une table. Ce tableau contiendra plus d'une colonne ayant le type de données de gros objet.

>> Créer la table TBL_BLOB2 (TBL_BLOB BYTEA, TBL1_BLOB BYTEA, TBL2_BLOB BYTEA, ID Integer, Name Varchar (10), Address Varchar (10), classe Varchar (10));

Après la création, utilisez à nouveau la commande écrite ci-dessous pour voir la description du tableau.

>> \ d + tbl_blob2;

Jusqu'à présent, nous avons vu l'utilisation de blob tout en créant la table. Mais pour ajouter une nouvelle colonne ayant un type de données de bytea et de blob, nous avons besoin d'une commande de mise à jour. Dans le tableau TBL_BLOB1, nous avons ajouté une colonne nommée TBL1_BLOB qui a le type de données de Bytea.

>> ALTER TABLE TBL_BLOB1 ADD COLUMN TBL1_BLOB BYTEA;

Création de grands objets dans PostgreSQL

Il existe une fonction pour créer un grand objet.

# Oid lo_creat (pgConn * con, mode int);

Dans cette fonction, le «mode» est un masque à biberon utilisé pour décrire différents attributs de l'objet qui est nouvellement créé. Tandis que les constantes utilisées dans la fonction sont présentes dans la bibliothèque du fichier d'en-tête libpq-fs. Ici, nous appliquons un exemple d'exemple pour la création d'objets importants, dans laquelle la valeur est renvoyée et acceptée par une variable.

# inv_oid = lo_creat (inv_read | inv_write);

La lecture et l'écriture sont les types d'accès utilisés dans la fonction. Un argument «-1» est utilisé comme paramètre de la fonction lo_creat () pour créer un grand objet dans l'exemple donné. Ceci est utilisé pour créer un nouveau grand, vide, montrant l'index comme nul.

>> sélectionnez lo-_creat (-1);

Une valeur aléatoire est allouée par PostgreSQL. Pour fournir une valeur spécifique pour créer un grand objet, nous fournissons une valeur de notre propre choix dans le paramètre.

>> sélectionnez lo_create (9945621);

Importer un grand objet

Si vous souhaitez importer un fichier présent dans n'importe quel répertoire de votre système d'exploitation comme un grand objet, cela peut être utilisé comme appel de fonction.

# OID LO_IMPORT (PGCONN * Conn, const char * name_of_file);

Name_of_file est le fichier spécifique que vous souhaitez importer depuis le système en tant que grand objet. La valeur OID qui est affectée à un nouvel objet grand est la valeur renvoyée.

Exporter un grand objet

Contrairement à l'importation, les grands objets peuvent également être exportés dans le système d'exploitation. Un appel de fonction pour exporter le grand objet est fait.

# Int lo_export (pgCon * Conn, oid lobjid, carré constant * name_of_file);

OID est montré par lobjid. OID est spécifié pour l'objet qui doit être exporté de PostgreSQL au système d'exploitation. L'argument du nom de fichier est qu'il spécifie le nom du système d'exploitation. Un grand ID d'objet est créé pour prendre en charge l'exportation du fichier de PostgreSQL vers le système d'exploitation.

Ouvrez un grand objet qui existe déjà dans PostgreSQL

Si vous souhaitez ouvrir un détail grand objet qui est déjà présent et créé auparavant dans PostgreSQL, alors la fonction suivante est utilisée.

# Int lo_open (pgCon * con, oid lojid, mode int);

Le grand objet est ouvert à des fins comme la lecture ou l'écriture ou pour les deux, toute mise à jour peut être effectuée. 'lo_open' Une variable de type entier, renvoie le grand objet pour une utilisation ultérieure dans lo_write, lo_read ou lo_close.

Écriture / lecture de données à / depuis le grand objet

Écrire des données à un grand objet

# Int lo_write (pgCon * Conn, int fx, const char * buffr, size_t lenn);

Le grand objet FX est utilisé pour écrire dans la longueur de Lenn à partir de Buffer Buffr. Les octets écrits sont retournés. Si la valeur de retour est négative, cela signifie qu'une erreur s'est produite.

Lire les données

# Int lo_read (pgConn * con, int fx, char * buffr, size_t lenn);

Cette fonction lit les octets de longueur Lenn du grand objet dans un tampon buffr. La valeur est retournée comme le processus d'écriture.

Élimination des objets

>> int lo_unlink (pgConn * con, oid lobjid);

Nous avons utilisé l'exemple ci-dessous à l'aide d'une commande SELECT avec un numéro OID. Le 'lo_unlink' est utilisé pour supprimer l'OID.

>> sélectionnez lo_unlink (9945621);

Implémenter de grandes commandes d'objets

Nous utiliserons certaines des caractéristiques susmentionnées d'un grand objet sur la coque PSQL. La première commande de création est utilisée pour créer une table du grand objet tel que nous l'avons fait ci-dessus.

>> Créer une table PIC (ID INTEGER, Nom Text, Pic OID);

Ici, le tableau est créé pour stocker les informations d'une image ayant le type de données de grand objet ID.

Insérer des valeurs dans le tableau

>> Insérer dans PIC (id, nom, pic) valeurs (1, «mon image», lo_import ('/ etc1 / Mottd »));

Une image du système d'exploitation est sélectionnée ici.

Conclusion

L'article «Postgres grand objet» contient la description de la spécialité d'utiliser le grand objet, ses types et certaines fonctions importantes utilisées pour créer, importer et exporter de grands objets postgresql. Certaines fonctionnalités sont implémentées sur le shell PostgreSQL pour élaborer la création et le travail de grands objets pour stocker des données.