Postgres großes Objekt

Große Objekte (Lobs) sind diese Datentypsammlungen, die erstellt wurden, um eine große Menge an Daten bis zu einer maximalen Größe zu enthalten, die von 8 Terabyte bis 128 Terabyte reicht. Es hängt hauptsächlich von der Konfiguration einer Datenbank ab.

Warum große Objekte in PostgreSQL verwendet werden

Wir werden verschiedene Arten von Daten erklären, die für große Objekte geeignet sind, und für ihren Schöpfungszweck.

• Strukturierte Daten: Dies ist eine einfache Art von strukturierten Daten und kann in einer einfachen Tabelle erstellt werden.
• Komplexe strukturierte Daten: Dies sind komplexe Strukturen und wurden erstellt, um die Funktionen der Objektrelation der Oracle-Datenbank wie Sammlungen und Referenzen zu verwalten.
• Unstrukturierte Daten: Diese Datenarten werden nicht von der Datenbank interpretiert, und diese Daten werden nicht in kleinere logische Strukturen unterteilt.

Syntax

# CREATE TABLE TABLE_NAME (name_of_column1 data_type, name_of_column2 data_type, name_of_columnn bytea);

Eine Tabelle für ein großes Objekt wird mit dem Datentyp einer bestimmten Spalte mit einer Bytea oder einem Blob erstellt, um die Werte für ein großes Objekt wie Bilder oder Videos zu speichern.

Implementierung

Wir erstellen eine Tabelle mit dem Datentyp des Blobs in einer Spalte, während andere Spalten integer und varchar -Datentypen haben. Bei der Ausführung einer Abfrage verursacht dies jedoch einen Fehler, indem angezeigt wird, dass der Typ "Blob" nicht existiert.

>> TABLE TBL_BLOB CREATE CREATE CREATE (TBL_BLOB BLOB, ID Ganzzahl, Name varchar (10), Adress varchar (10));

Wir werden dieselben Tabellenattribute erneut erstellen, indem wir die erste Spalte mit dem Datentyp "Bytea" haben. Dies ist auch ein Typ-Variablentyp vom Blob-Typ. Durch die Verwendung können wir die Daten des Binärtyps in PostgreSQL wiederherstellen.

>> TABLE TBL_BLOB CREATE CREATE CREATE (TBL_BLOB BYTEA, ID Ganzzahl, Name varchar (10), Adress varchar (10));

Dies wurde getan, um den Unterschied in der Verwendung von Blob und Bytea zu zeigen. Meistens ist Blob nicht mit einigen Versionen von PostgreSQL kompatibel. Deshalb verwenden wir Bytea im Befehl.

Eine neue Beispieltabelle wird erneut erstellt, um die Verwendung des großen Objekts zu testen. Eine Tabelle mit dem Namen TBL_Blob1 wird erstellt.

>> TABLE TBL_BLOB1 (TBL_BLOB BYTEA, ID Ganzzahl, Name Varchar (10), Adress varchar (10), Klasse erstellen

varchar (10)); [/cc]

Nach dem Erstellen der Tabelle werden nun die Beschreibung der Tabelle angezeigt, um den Speichertyp und die Spaltentypen zu notieren.

>> \ d+ tbl_blol1;

Sie können im obigen Bild sehen, dass die Spaltennamen und der Datentyp angezeigt werden. Die Methode, die zum Zugriff auf diese Beschreibung verwendet wird, ist die Heap -Sortierung. Um die Verwendung großer Objekte in mehr als einer Spalte zu erklären, werden wir erneut eine Tabelle erstellen. Diese Tabelle enthält mehr als eine Spalte mit dem großen Objektdatentyp.

>> TABLE TBL_BLOB2 (TBL_BLOB BYTEA, TBL1_BLOB BYTEA, TBL2_BLOB BYTEA, ID Ganzzahl, Name Varchar (10), Adress varchar (10), Klasse varchar (10));

Verwenden Sie nach der Erstellung erneut den unten geschriebenen Befehl, um die Tabellenbeschreibung anzuzeigen.

>> \ d+ tbl_blob2;

Bis jetzt haben wir die Verwendung von Blob beim Erstellen des Tisches gesehen. Um jedoch eine neue Spalte mit einem Datentyp von Bytea und Blob hinzuzufügen, benötigen wir einen Aktualisierungsbefehl. In Tabelle TBL_Blob1 haben wir eine Spalte mit dem Namen TBL1_Blob mit dem Datentyp von Bytea hinzugefügt.

>> TABLE TBL_BLOB1 Fügen Sie Spalte TBL1_Blob Bytea hinzu;

Große Objekterstellung in PostgreSQL

Es gibt eine Funktion, um ein großes Objekt zu erstellen.

# Oid lo_creat (pgconn *con, int modus);

In dieser Funktion ist 'Modus' eine Bitmaske, mit der verschiedene Attribute des neu erstellten Objekts beschrieben werden. Während die in der Funktion verwendeten Konstanten in der Bibliothek der Header-Datei LIBPQ-FS vorhanden sind. Hier wenden wir ein Beispielbeispiel für die große Objekterstellung an, bei der der Wert von einer Variablen zurückgegeben und akzeptiert wird.

# inv_oid = lo_creat (inv_read | inv_write);

Das Lesen und Schreiben sind die in der Funktion verwendeten Zugriffstypen. Ein „-1“ -Argument wird als Parameter der Funktion lo_creat () verwendet, um ein großes Objekt im angegebenen Beispiel zu erstellen. Dies wird verwendet, um eine neue große, leer zu erstellen, die den Index als Null zeigt.

>> Wählen Sie lo-_creat (-1);

Ein zufälliger Wert wird von PostgreSQL zugeteilt. Um einen bestimmten Wert zu bieten, um ein großes Objekt zu erstellen, bieten wir einen Wert unserer eigenen Wahl im Parameter.

>> Wählen Sie lo_create (9945621);

Großes Objekt importieren

Wenn Sie eine Datei in einem Verzeichnis Ihres Betriebssystems als großes Objekt importieren möchten, kann dies als Funktionsaufruf verwendet werden.

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

Name_of_file ist die spezifische Datei, die Sie als großes Objekt aus dem System importieren möchten. Der OID -Wert, der einem neuen großen Objekt zugeordnet ist, ist der zurückgegebene Wert.

Exportieren Sie ein großes Objekt

Im Gegensatz zum Import können auch große Objekte in das Betriebssystem exportiert werden. Ein Funktionsaufruf zum Exportieren des großen Objekts wird gemacht.

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

OID wird durch Lobjid gezeigt. OID ist für das Objekt angegeben, das von postgreSQL in das Betriebssystem exportiert werden muss. Das Argument des Dateinamens ist, dass er den Namen des Betriebssystems angibt. Eine große Objekt -ID wird erstellt, um den Export der Datei von PostgreSQL in das Betriebssystem zu unterstützen.

Öffnen Sie ein großes Objekt, das bereits in Postgresql existiert

Wenn Sie ein großes Objektdetail öffnen möchten, das bereits in PostgreSQL vorhanden und erstellt wurde, wird die folgende Funktion verwendet.

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

Das große Objekt wird für jeden Zweck wie Lesen oder Schreiben geöffnet oder für beide, jedes Update kann durchgeführt werden. 'lo_open' eine Ganzzahl -Typvariable, gibt das große Objekt für die spätere Verwendung in lo_write, lo_read oder lo_close zurück.

Schreiben/Lesen von Daten zum/vom großen Objekt

Schreiben Sie Daten in ein großes Objekt

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

Das große Objekt FX wird verwendet, um in der Länge von Lenn aus Buffer Buffr zu schreiben. Die geschriebenen Bytes werden zurückgegeben. Wenn der Rückgabewert negativ ist, bedeutet dies, dass ein Fehler aufgetreten ist.

Daten lesen

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

Diese Funktion liest die Lenn -Längen -Bytes des großen Objekts in einen Buffers Buffr. Der Wert wird zurückgegeben wie der Schreibprozess.

Große Objektentfernung

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

Wir haben das folgende Beispiel mit einem SELECT-Befehl mit einer OID-Nummer verwendet. Mit dem 'lo_unlink' wird das OID entfernen.

>> Wählen Sie lo_unlink (9945621);

Implementieren Sie große Objektbefehle

Wir werden einige der oben genannten Merkmale eines großen Objekts auf PSQL-Shell verwenden. Der erste Befehl erstellen wird verwendet, um eine Tabelle des großen Objekts zu erstellen, wie wir es oben getan haben.

>> Tabellenbild erstellen (ID Ganzzahl, Name Text, Bild OID);

Hier wird die Tabelle erstellt, um die Informationen eines Bildes mit dem Datentyp der großen Objekt -ID zu speichern.

Werte in die Tabelle einfügen

>> in pic (id, name, pic) Werte einfügen (1, 'mein Bild', lo_import ('/etc1/mottd'));

Ein Bild aus dem Betriebssystem wird hier ausgewählt.

Abschluss

Der Artikel "Postgres Large Object" enthält die Beschreibung der Spezialität der Verwendung des großen Objekts, seiner Typen und einige wichtige Funktionen,. Einige der Funktionen werden in der PostgreSQL -Shell implementiert, um die Erstellung und Arbeiten großer Objekte zum Speichern von Daten zu erarbeiten.