Postgres Oggetto grande

Oggetti di grandi dimensioni (LOB) sono quelle raccolte di tipi di dati create per contenere una grande quantità di dati fino a una dimensione massima che varia da 8 terabyte a 128 terabyte. Dipende principalmente dalla configurazione di un database.

Perché gli oggetti di grandi dimensioni vengono utilizzati in PostgreSQL

Spiegheremo diversi tipi di dati adatti a oggetti di grandi dimensioni e al loro scopo di creazione.

• Dati strutturati: Questo è un semplice tipo di dati strutturati e può essere creato in una tabella semplice.
• Dati strutturati complessi: Queste sono strutture complesse e sono create per gestire le caratteristiche della relazione agli oggetti del database Oracle come raccolte e riferimenti.
• Dati non strutturati: Questi tipi di dati non sono interpretati dal database e questi tipi di dati non sono suddivisi in strutture logiche più piccole.

Sintassi

# Crea table table_name (name_of_column1 data_type, name_of_column2 data_type, name_of_columnn bytea);

Una tabella per un oggetto grande viene creata con il tipo di dati di una colonna specifica con una bytea o un blob per archiviare i valori per un oggetto di grandi dimensioni come immagini o video.

Implementazione

Creeremo una tabella con il tipo di dati di BLOB in una colonna, mentre altre colonne hanno tipi di dati interi e varchar. Ma sull'esecuzione di una query, ciò provoca un errore visualizzando che il tipo "blob" non esiste.

>> Crea tabella TBL_BLOB (TBL_BLOB BLOB, ID intero, nome varchar (10), indirizzo varchar (10));

Creeremo di nuovo gli stessi attributi della tabella avendo la prima colonna con il tipo di dati di "bytea". Questo è anche un tipo di variabile di dati di tipo BLOB. Usando questo, possiamo ripristinare i dati del tipo binario in PostgreSQL.

>> Crea tabella TBL_BLOB (TBL_BLOB BYTEA, ID integer, nome varchar (10), indirizzo varchar (10));

Questo è stato fatto per mostrare la differenza nell'uso di blob e bytea. Molto spesso, BLOB non è compatibile con alcune versioni di PostgreSQL; Ecco perché usiamo la bytea nel comando.

Verrà nuovamente creato una nuova tabella di esempio per testare l'uso dell'oggetto grande. Viene creata una tabella chiamata TBL_BLOB1.

>> Crea tabella TBL_BLOB1 (TBL_BLOB BYTEA, ID integer, nome Varchar (10), indirizzo Varchar (10), classe

varchar (10)); [/cc]

Dopo aver creato la tabella, ora vedremo la descrizione della tabella per notare il tipo di archiviazione e i tipi di colonna.

>> \ d+ TBL_BLOL1;

Puoi vedere nell'immagine sopra che vengono visualizzati i nomi delle colonne e il tipo di dati. Il metodo utilizzato per accedere a questa descrizione è l'ordinamento. Per spiegare l'uso di oggetti di grandi dimensioni in più di una colonna, creeremo di nuovo una tabella. Questa tabella conterrà più di una colonna con il tipo di dati di oggetti di grandi dimensioni.

>> Crea tabella TBL_BLOB2 (TBL_BLOB BYTEA, TBL1_BLOB BYTEA, TBL2_BLOB BYTEA, ID Integer, nome Varchar (10), indirizzo Varchar (10), classe Varchar (10));

Dopo la creazione, usa nuovamente il comando scritto di seguito per vedere la descrizione della tabella.

>> \ d+ tbl_blob2;

Fino ad ora, abbiamo visto l'uso di BLOB mentre creiamo il tavolo. Ma per aggiungere una nuova colonna con un tipo di dati di bytea e blob, abbiamo bisogno di un comando di aggiornamento. Nella tabella TBL_BLOB1, abbiamo aggiunto una colonna denominata TBL1_BLOB che ha il tipo di dati di BYTEA.

>> Alter Tabella TBL_BLOB1 Aggiungi colonna TBL1_BLOB BYTEA;

Grande creazione di oggetti in PostgreSQL

Esiste una funzione per creare un oggetto grande.

# Oid lo_creat (pgconn *con, int modalità);

In questa funzione, "modalità" è una maschera bit che viene utilizzata per descrivere diversi attributi dell'oggetto che viene appena creato. Mentre le costanti utilizzate nella funzione sono presenti nella libreria del file di intestazione libpq-fs. Qui applichiamo un esempio di esempio per la creazione di oggetti di grandi dimensioni, in cui il valore viene restituito e accettato da una variabile.

# inv_id = lo_creat (inv_read | inv_write);

Le letture e la scrittura sono i tipi di accesso utilizzati nella funzione. Un argomento "-1" viene utilizzato come parametro della funzione Lo_Creat () per creare un oggetto grande nell'esempio dato. Questo viene utilizzato per creare un nuovo grande, vuoto, che mostra l'indice come null.

>> Seleziona lo -_creat (-1);

Un valore casuale è assegnato da PostgreSQL. Per fornire un valore specifico per creare un oggetto di grandi dimensioni, forniamo un valore della nostra scelta nel parametro.

>> Seleziona Lo_Create (9945621);

Importare oggetti grandi

Se si desidera importare un file presente in qualsiasi directory del sistema operativo come oggetto di grande, allora può essere utilizzato come chiamata di funzione.

# Oid lo_import (pgconn *conn, const char *name_of_file);

Name_of_file è il file specifico che si desidera importare dal sistema come un oggetto di grandi dimensioni. Il valore OID assegnato a un nuovo oggetto grande è il valore restituito.

Esporta un oggetto grande

Contrariamente all'importazione, oggetti di grandi dimensioni possono anche essere esportati nel sistema operativo. Viene effettuata una chiamata di funzione per esportare l'oggetto grande.

# Int lo_export (pgcon *conn, oid lobjid, costante char *name_of_file);

OID è mostrato da lobjid. OID è specificato per l'oggetto che deve essere esportato da PostgreSQL al sistema operativo. L'argomento del nome file è che specifica il nome del sistema operativo. Viene creato un ID oggetto di grandi dimensioni per supportare l'esportazione del file da PostgreSQL al sistema operativo.

Apri un oggetto di grandi dimensioni che esiste già in PostgreSQL

Se si desidera aprire un dettaglio di oggetti di grandi dimensioni che è già presente e creato prima in PostgreSQL, viene utilizzata la seguente funzione.

# Int lo_open (pgcon *con, oid lojid, int modalità);

L'oggetto grande è aperto per qualsiasi scopo come la lettura o la scrittura o per entrambi, è possibile eseguire qualsiasi aggiornamento. 'lo_open' Una variabile di tipo intero, restituisce l'oggetto grande per un uso successivo in lo_write, lo_read o lo_close.

Scrivere/leggere i dati da/dal grande oggetto

Scrivi i dati su un oggetto grande

# Int lo_write (pgcon *conn, int fx, const char *buffr, size_t lenn);

L'oggetto grande FX viene utilizzato per scrivere nella lunghezza di Lenn dal buffr buffr. I byte che vengono scritti vengono restituiti. Se il valore di ritorno è negativo, significa che si è verificato un errore.

Leggi i dati

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

Questa funzione legge i byte di lunghezza Lenn dell'oggetto grande in un buffr buffer. Il valore viene restituito come fa il processo di scrittura.

Rimozione di grandi oggetti

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

Abbiamo usato l'esempio citato di seguito utilizzando un comando seleziona con un numero OID. Il "lo_unlink" viene utilizzato per rimuovere l'OID.

>> Seleziona lo_unlink (9945621);

Implementare i comandi di oggetti di grandi dimensioni

Useremo alcune delle caratteristiche sopra menzionate di un oggetto di grandi dimensioni su PSQL Shell. Il primo comando Crea viene utilizzato per creare una tabella dell'oggetto grande come abbiamo fatto sopra.

>> Crea tabella foto (ID intero, testo del nome, foto oid);

Qui la tabella viene creata per archiviare le informazioni di un'immagine con il tipo di dati di ID oggetto grande.

Inserire i valori nella tabella

>> Inserisci in pic (id, nome, foto) valori (1, 'my immagine', lo_import ('/etc1/mottd'));

Un'immagine del sistema operativo è selezionata qui.

Conclusione

L'articolo "Postgres Large Object" contiene la descrizione della specialità dell'utilizzo dell'oggetto grande, dei suoi tipi e alcune importanti funzioni utilizzate nella creazione, importazione ed esportazione di oggetti PostgreSQL di grandi dimensioni. Alcune delle funzionalità sono implementate sulla shell PostgreSQL per elaborare la creazione e il funzionamento di oggetti di grandi dimensioni per archiviare i dati.