Postgres stort objekt

Store objekter (lobber) er disse datatypesamlingene som er opprettet for å inneholde en stor mengde data opp til en maksimal størrelse som varierer fra 8 terabyte til 128 terabyte. Det avhenger hovedsakelig av konfigurasjonen av en database.

Hvorfor store gjenstander brukes i PostgreSQL

Vi vil forklare forskjellige typer data som er egnet for store objekter og deres skapelsesformål.

• Strukturerte data: Dette er en enkel type strukturerte data og kan opprettes i en enkel tabell.
• Komplekse strukturerte data: Dette er komplekse strukturer og er opprettet for å administrere funksjonene i objektrelasjonell av Oracle-databasen som samlinger og referanser.
• Ustrukturerte data: Denne typen data tolkes ikke av databasen, og denne typen data blir ikke brutt i mindre logiske strukturer.

Syntaks

# Opprett tabell tabell_navn (name_of_column1 data_type, name_of_column2 data_type, name_of_columnn bytea);

En tabell for et stort objekt opprettes med datatypen til en spesifikk kolonne som har en bytea eller klatt for å lagre verdiene for et stort objekt som bilder eller videoer.

Gjennomføring

Vi vil lage en tabell med datatypen av BLOB i en kolonne, mens andre kolonner har heltall og varchar datatyper. Men ved utførelse av en spørring forårsaker dette en feil ved å vise at 'Blob' -typen ikke eksisterer.

>> Lag tabell TBL_BLOB (TBL_BLOB BLOB, ID -heltall, navn varchar (10), adresse varchar (10));

Vi vil opprette de samme tabellattributtene igjen ved å ha den første kolonnen med datatypen 'Bytea'. Dette er også en datavariabel type BLOB-type. Ved å bruke dette kan vi gjenopprette dataene fra binær type i PostgreSQL.

>> Lag tabell tbl_blob (tbl_blob bytea, id heltall, navn varchar (10), adresse varchar (10));

Dette ble gjort for å vise forskjellen i bruk av BLOB og bytea. Oftest er BLOB ikke kompatibel med noen versjoner av PostgreSQL; Derfor bruker vi bytea i kommandoen.

Det opprettes en ny eksempeltabell for å teste bruken av det store objektet. En tabell som heter TBL_BLOB1 er opprettet.

>> Lag tabell TBL_BLOB1 (TBL_BLOB BYTEA, ID -heltall, navn varchar (10), adresse varchar (10), klasse

varchar (10)); [/cc]

Etter å ha opprettet tabellen, vil vi nå se beskrivelsen av tabellen for å merke lagringstypen og kolonnetypene.

>> \ d+ tbl_blol1;

Du kan se i bildet ovenfor at kolonnenavnene og datatypen vises. Metoden som brukes til å få tilgang til denne beskrivelsen er haugesort. For å forklare bruken av store objekter i mer enn en kolonne, vil vi igjen lage en tabell. Denne tabellen vil inneholde mer enn en kolonne som har den store objektdatatypen.

>> Opprett tabell TBL_BLOB2 (TBL_BLOB BYTEA, TBL1_BLOB BYTEA, TBL2_BLOB BYTEA, ID -heltall, navn varchar (10), adresse varchar (10), klasse varchar (10));

Etter opprettelsen, bruk igjen kommandoen skrevet nedenfor for å se tabellbeskrivelsen.

>> \ d+ tbl_blob2;

Til nå har vi sett bruken av Blob mens vi lager bordet. Men for å legge til en ny kolonne som har en datatype av bytea og Blob, trenger vi en oppdateringskommando. I tabell TBL_BLOB1 har vi lagt til en kolonne som heter TBL1_BLOB som har datatypen til Byta.

>> alter tabell tbl_blob1 legg til kolonne tbl1_blob bytea;

Stor objektoppretting i PostgreSql

Det eksisterer en funksjon for å lage et stort objekt.

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

I denne funksjonen er 'modus' en bitmask som brukes til å beskrive forskjellige attributter til objektet som er nyopprettet. Mens konstantene som brukes i funksjonen er til stede i biblioteket med overskriftsfilen Libpq-FS. Her bruker vi et eksempeleksempel for den store objektopprettelsen, der verdien returneres og aksepteres av en variabel.

# inv_oid = lo_creat (inv_read | inv_write);

Les og skriv er tilgangstypene som brukes i funksjonen. Et "-1" -argument brukes som en parameter for lo_creat () -funksjonen for å lage et stort objekt i det gitte eksemplet. Dette brukes til å lage en ny stor, tom, og viser indeksen som null.

>> velg lo-_ creat (-1);

En tilfeldig verdi tildeles av PostgreSQL. For å gi en spesifikk verdi for å opprette et stort objekt, gir vi en verdi av vårt eget valg i parameteren.

>> velg lo_create (9945621);

Importere stort objekt

Hvis du vil importere en fil som er til stede i en hvilken som helst katalog i operativsystemet ditt som et stort objekt, kan dette brukes som funksjonsanrop.

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

Name_of_file er den spesifikke filen du vil importere fra systemet som et stort objekt. OID -verdien som er tilordnet et nytt stort objekt er den returnerte verdien.

Eksporter et stort objekt

I motsetning til import, kan store objekter også eksporteres til operativsystemet. En funksjonsanrop for å eksportere det store objektet gjøres.

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

OID vises av Lobjid. OID er spesifisert for objektet som må eksporteres fra PostgreSQL til operativsystemet. Argumentet for filnavnet er at det spesifiserer navnet på operativsystemet. En stor objekt -ID opprettes for å støtte eksport av filen fra PostgreSQL til operativsystemet.

Åpne et stort objekt som allerede eksisterer i PostgreSQL

Hvis du vil åpne en stor objektdetalj som allerede er til stede og opprettet før i PostgreSQL, brukes følgende funksjon.

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

Det store objektet åpnes for ethvert formål som lesing eller skriving eller for begge deler, kan enhver oppdatering gjøres. 'lo_open' En heltallstypevariabel, returnerer det store objektet for senere bruk i lo_write, lo_read eller lo_close.

Skrive/lese data til/fra det store objektet

Skriv data til stort objekt

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

Det store objektet FX brukes til å skrive i lengden på Lenn fra Buffer Buffr. Byte som er skrevet blir returnert. Hvis returverdien er negativ, betyr det at det har oppstått en feil.

Les data

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

Denne funksjonen leser Lenn Length Bytes av det store objektet i en bufferbuffr. Verdien returneres som skriveprosessen gjør.

Stor gjenstandsfjerning

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

Vi har brukt det nedenfor siterte eksemplet ved hjelp av en SELECT-kommando med et OID-nummer. 'Lo_unlink' brukes til å fjerne OID.

>> velg lo_unlink (9945621);

Implementere store objektkommandoer

Vi vil bruke noen av de ovennevnte funksjonene til et stort objekt på PSQL-skallet. Den første Create -kommandoen brukes til å lage en tabell over det store objektet da vi gjorde det ovenfor.

>> Lag tabellbilde (ID heltall, navnetekst, bilde oid);

Her er tabellen opprettet for å lagre informasjonen til et bilde som har datatypen til stor objekt -ID.

Sett inn verdier i tabellen

>> sett inn i PIC (ID, navn, PIC) verdier (1, 'Mitt bilde', lo_import ('/etc1/Mottd'));

Et bilde fra operativsystemet er valgt her.

Konklusjon

Artikkelen 'Postgres Large Object' inneholder beskrivelsen av spesialiteten ved å bruke det store objektet, dens typer og noen viktige funksjoner som brukes til å lage, importere og eksportere store postgreSQL -objekter. Noen av funksjonene implementeres på PostgreSql -skallet for å utdype opprettelsen og arbeidet med store objekter for å lagre data.