PostgreSQL - Datatyper - Tutorialspoint

Numeriska typer

Numeriska typer består av två-byte, fyra-byte och åtta-byte heltal, fyra-byte och åtta-byte flyttalstal och decimaler med valbar precision. I följande tabell visas de tillgängliga typerna.

Namn	Lagringsstorlek	Beskrivning	Utbud
smallint	2 bytes	small-range heltal	-32768 till +32767
integer	4 bytes	typiskt val för heltal	-2147483648 till +2147483647
bigint	8 bytes	normalt heltal	-9223372036854775808 till 9223372036854775807
decimal	variabel	användarspecifik precision,exakt	upp till 131072 siffror före decimalpunkten; upp till 16383 siffror efter decimalpunkten
numerisk	variabel	användarspecificerad precision, exakt	upp till 131072 siffror före decimalpunkten; upp till 16383 siffror efter decimalpunkten
real	4 bytes	variabel precision,inexakt	6 decimalsiffror precision
dubbel precision	8 bytes	variabel precision,inexakt	15 decimalsiffror precision
smallseriell	2 bytes	small autoinkrementering heltal	1 till 32767
seriell	4 bytes	autoinkrementerande heltal	1 till 2147483647
bigserial	8 bytes	stort autoinkrementerande heltal	1 till 9223372036854775807

Monetärtyper

Penningtypen lagrar ett valutabelopp med en fast bråkprecision. Värden av datatyperna numeric, int och bigint kan kastas till money. Användning av flyttal rekommenderas inte för att hantera pengar på grund av risken för avrundningsfel.

Namn	Lagringsstorlek	Beskrivning	Utbud
pengar	8 bytes	valutasumma	-92233720368547758.08 till +92233720368547758.07

Teckentyper

Tabellen nedan innehåller en förteckning över de allmänna teckentyper som finns tillgängliga i PostgreSQL.

S. Nr.	Namn & Beskrivning
1	Karaktär som varierar(n), varchar(n) variabel längd med gräns
2	tecken(n), char(n) fast längd, blank padded
3	text variabel obegränsad längd

S. Nr.

Namn & Beskrivning

Karaktär som varierar(n), varchar(n)

variabel längd med gräns

tecken(n), char(n)

fast längd, blank padded

text

variabel obegränsad längd

Binära datatyper

Datatypen bytea möjliggör lagring av binära strängar enligt tabellen nedan.

Namn	Lagringsstorlek	Beskrivning
bytea	1 eller 4 bytes plus den faktiska binära strängen	variabel-längd binärsträng

Dato- och tidstyper

PostgreSQL har stöd för en fullständig uppsättning SQL-dato- och tidstyper, som visas i tabellen nedan. Datum räknas enligt den gregorianska kalendern. Här har alla typerna en upplösning på 1 mikrosekund / 14 siffror utom datumtypen, vars upplösning är dag.

Namn	Slagringsstorlek	Beskrivning	Lågt värde	Högt värde
tidsstämpel	8 Bytes	både datum och tid (ingen tidszon)	4713 BC	294276 AD
TIMESTAMPTZ	8 bytes	både datum och tid, med tidszon	4713 BC	294276 AD
datum	4 bytes	datum (ingen tid på dagen)	4713 BC	5874897 AD
time	8 bytes	tid på dagen (inget datum)	00:00:00	24:00:00
tid med tidszon	12 bytes	något om dagen, endast med tidszon	00:00:00+1459	24:00:00-1459
intervall	12 bytes	tidsintervall	-178000000 år	178000000 år

Boolisk typ

PostgreSQL tillhandahåller den standardiserade SQL-typen Boolean. Den booleska datatypen kan ha tillstånden true (sant), false (falskt) och ett tredje tillstånd, unknown (okänt), som representeras av SQL-värdet null (noll).

Namn	Lagringsstorlek	Beskrivning
boolean	1 byte	tillståndet sant eller falskt

Enumererad typ

Enumererade (enum) typer är datatyper som omfattar en statisk, ordnad uppsättning av värden. De motsvarar de enumtyper som stöds i ett antal programmeringsspråk.

Till skillnad från andra typer måste uppräknade typer skapas med kommandot CREATE TYPE. Den här typen används för att lagra en statisk, ordnad uppsättning värden. Till exempel kompassriktningar, dvs. NORTH, SOUTH, EAST och WEST eller veckodagar enligt nedan –

CREATE TYPE week AS ENUM ('Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun');

Enumerated kan efter att ha skapats användas på samma sätt som alla andra typer.

Geometric Type

Geometriska datatyper representerar tvådimensionella rumsliga objekt. Den mest grundläggande typen, punkten, utgör grunden för alla andra typer.

Namn	Lagringsstorlek	Representation	Beskrivning
Punkt	16 bytes	Punkt på ett plan	(x,y)
linje	32 bytes	Oändlig linje (inte helt implementerat)	((x1,y1),(x2,y2))
lseg	32 bytes	Enligt linjesegment	((x1,y1),(x2,y2))
box	32 bytes	Rektangulär box	((x1,y1),(x2,y2))
sökväg	16+16n bytes	Sluten sökväg (liknande polygon)	((x1,y1),…)
sökväg	16+16n bytes	Öppen sökväg
polygon	40+16n	Polygon (liknar sluten sökväg)	((x1,y1),…)
circle	24 bytes	Circle	<(x,y),r> (centrumpunkt och radie)

Nätverksadress-typ

PostgreSQL erbjuder datatyper för att lagra IPv4, IPv6 och MAC-adresser. Det är bättre att använda dessa typer istället för vanliga texttyper för att lagra nätverksadresser, eftersom dessa typer erbjuder inmatningsfelkontroll och specialiserade operatörer och funktioner.

Namn	Lagringsstorlek	Beskrivning
cidr	7 eller 19 bytes	IPv4- och IPv6-nätverk
inet	7 eller 19. bytes	IPv4- och IPv6-värdar och nätverk
macaddr	6 bytes	MAC-adresser

Bit String Type

Bit String Types används för att lagra bitmasker. De är antingen 0 eller 1. Det finns två SQL-bitstyper: bit(n) och bit varying(n), där n är ett positivt heltal.

Textsökningstyp

Denna typ stöder fulltextsökning, vilket är aktiviteten att söka genom en samling av dokument i naturligt språk för att hitta de dokument som bäst matchar en förfrågan. Det finns två datatyper för detta –

S. No.	Namn & Beskrivning
1	tsvector Detta är en sorterad lista över distinkta ord som har normaliserats för att slå samman olika varianter av samma ord, så kallade ”lexem”.
2	tsquery Detta lagrar lexem som ska sökas och kombinerar dem med respekt för de booleska operatörerna & (AND), \| (OR) och ! (NOT). Parenteser kan användas för att tvinga fram gruppering av operatörerna.

S. No.

Namn & Beskrivning

tsvector

Detta är en sorterad lista över distinkta ord som har normaliserats för att slå samman olika varianter av samma ord, så kallade ”lexem”.

tsquery

Detta lagrar lexem som ska sökas och kombinerar dem med respekt för de booleska operatörerna & (AND), | (OR) och ! (NOT). Parenteser kan användas för att tvinga fram gruppering av operatörerna.

UUID Typ

En UUID (Universally Unique Identifiers) skrivs som en sekvens av hexadecimala siffror med små bokstäver, i flera grupper som skiljs åt av bindestreck, närmare bestämt en grupp med åtta siffror, följt av tre grupper med fyra siffror, följt av en grupp med 12 siffror, för totalt 32 siffror som representerar de 128 bitarna.

Ett exempel på ett UUID är – 550e8400-e29b-41d4-a716-446655440000

XML-typ

Den XML-datatypen kan användas för att lagra XML-data. För att lagra XML-data måste du först skapa XML-värden med hjälp av funktionen xmlparse enligt följande –

XMLPARSE (DOCUMENT '<?xml version="1.0"?><tutorial><title>PostgreSQL Tutorial </title> <topics>...</topics></tutorial>')XMLPARSE (CONTENT 'xyz<foo>bar</foo><bar>foo</bar>')

JSON Type

Datatypen json kan användas för att lagra JSON-data (JavaScript Object Notation). Sådana data kan också lagras som text, men json-datatypen har fördelen att den kontrollerar att varje lagrat värde är ett giltigt JSON-värde. Det finns också relaterade stödfunktioner som kan användas direkt för att hantera JSON-datatypen enligt följande.

Exempel	Exempel Resultat
array_to_json(’{{1,5},{99,100}}’::int)	,]
row_to_json(row(1,’foo’))	{”f1”:1, ”f2”: ”foo”}

Array Type

PostgreSQL ger möjlighet att definiera en kolumn i en tabell som en multidimensionell array med variabel längd. Arrayer av vilken inbyggd eller användardefinierad bastyp, enumtyp eller sammansatt typ som helst kan skapas.

Deklaration av matriser

Matriser kan deklareras som

CREATE TABLE monthly_savings ( name text, saving_per_quarter integer, scheme text);

eller genom att använda nyckelordet ”ARRAY” som

CREATE TABLE monthly_savings ( name text, saving_per_quarter integer ARRAY, scheme text);

Insättning av värden

Matriser kan sättas in som bokstavskonstanter, genom att omsluta elementvärdena inom parenteser och separera dem med kommatecken. Ett exempel visas nedan –

INSERT INTO monthly_savings VALUES ('Manisha', '{20000, 14600, 23500, 13250}', '{{"FD", "MF"}, {"FD", "Property"}}');

Accessing Arrays

Ett exempel för accessing Arrays visas nedan. Kommandot nedan kommer att välja ut de personer vars sparande är större under andra kvartalet än under fjärde kvartalet.

SELECT name FROM monhly_savings WHERE saving_per_quarter > saving_per_quarter;

Modifiera matriser

Ett exempel på att modifiera matriser visas nedan.

UPDATE monthly_savings SET saving_per_quarter = '{25000,25000,27000,27000}'WHERE name = 'Manisha';

eller genom att använda syntaxen för ARRAY-uttryck –

UPDATE monthly_savings SET saving_per_quarter = ARRAYWHERE name = 'Manisha';

Sökning av matriser

Ett exempel på sökning av matriser visas nedan.

SELECT * FROM monthly_savings WHERE saving_per_quarter = 10000 ORsaving_per_quarter = 10000 ORsaving_per_quarter = 10000 ORsaving_per_quarter = 10000;

Om matrisens storlek är känd kan den sökmetod som anges ovan användas. Annars visar följande exempel hur man söker när storleken inte är känd.

SELECT * FROM monthly_savings WHERE 10000 = ANY (saving_per_quarter);

Composite Types

Denna typ representerar en lista med fältnamn och deras datatyper, dvs, struktur för en rad eller post i en tabell.

Deklaration av sammansatta typer

Följande exempel visar hur man deklarerar en sammansatt typ

CREATE TYPE inventory_item AS ( name text, supplier_id integer, price numeric);

Denna datatyp kan användas i skapa tabeller enligt nedan –

CREATE TABLE on_hand ( item inventory_item, count integer);

Inmatning av sammansatta värden

Sammansatta värden kan sättas in som en bokstavskonstant, genom att omsluta fältvärdena inom parenteser och separera dem med kommatecken. Ett exempel visas nedan –

INSERT INTO on_hand VALUES (ROW('fuzzy dice', 42, 1.99), 1000);

Detta gäller för inventory_item som definieras ovan. Nyckelordet ROW är faktiskt valfritt så länge du har mer än ett fält i uttrycket.

Accessing Composite Types

Om du vill komma åt ett fält i en sammansatt kolumn använder du en punkt följt av fältnamnet, ungefär som när du väljer ett fält från ett tabellnamn. Om du till exempel vill välja några delfält från vår exempeltabell on_hand skulle frågan se ut som nedan –

SELECT (item).name FROM on_hand WHERE (item).price > 9.99;

Du kan till och med använda tabellnamnet också (till exempel i en flerstegsfråga), som här –

SELECT (on_hand.item).name FROM on_hand WHERE (on_hand.item).price > 9.99;

Rangtyper

Rangtyper representerar datatyper som använder ett intervall av data. Intervalltyper kan vara diskreta intervall (t.ex. alla heltalsvärden 1 till 10) eller kontinuerliga intervall (t.ex, alla tidpunkter mellan 10:00 och 11:00).

Den byggda-tillgängliga inbyggda intervalltyper inkluderar följande intervall –

int4range – Range of heltal
int8range – Range of bigint
numrange – Range of numeric
tsrange – Range of numeric
tsrange – Område för tidsstämpel utan tidszon
tstzrange – Område för tidsstämpel med tidszon
daterange – Område för datum

Anpassade intervalltyper kan skapas för att göra nya typer av intervall tillgängliga, till exempel IP-adressintervall som använder inet-typen som bas eller float-intervall som använder float-datatypen som bas.

Rangtyper har stöd för inkluderande och exklusiva intervallgränser med hjälp av tecknen och ( ). Exempelvis representerar ’[4,9)’ alla heltal från och med 4 till och med 9.

Objektidentifieringstyper

Objektidentifierare (OID) används internt av PostgreSQL som primära nycklar för olika systemtabeller. Om WITH OIDS anges eller om konfigurationsvariabeln default_with_oids är aktiverad är det endast då som OID:er i sådana fall läggs till i användarskapade tabeller. I följande tabell listas flera aliastyper. Aliastyperna för OID har inga egna operationer förutom specialiserade rutiner för in- och utdata.

Namn		Beskrivning	Värde Exempel
oid	any	numerisk objektidentifierare	564182
regproc	pg_proc	funktionsnamn	sum
regförfarande	pg_proc	funktion med argumenttyper	sum(int4)
regoper	pg_operator	operatornamn	+
regoperator	pg_operator	operator med argumenttyper	*(heltal,heltal) eller -(NONE,heltal)
regclass	pg_class	relationsnamn	pg_type
regtype	pg_type	datatypnamn	integer
regconfig	pg_ts_config	konfiguration för textsökning	English
regdictionary	pg_ts_dict	textsökningsordbok	simple	simple

Pseudotyper

PostgreSQLs typsystem innehåller ett antal special-ändamål som kollektivt kallas pseudotyper. En pseudotyp kan inte användas som en kolumndatatyp, men den kan användas för att deklarera en funktions argument- eller resultattyp.

Tabellen nedan listar de befintliga pseudotyperna.

S. Nr.	Namn & Beskrivning
1	any Indikerar att en funktion accepterar en valfri indatatyp.
2	anyelement Indikerar att en funktion accepterar vilken datatyp som helst.
3	anyarray Indikerar att en funktion accepterar vilken array som helst.
4	anynonarray Indikerar att en funktion accepterar alla datatyper som inte är arrayer.
5	anyenum Indikerar att en funktion accepterar alla datatyper som inte är enum.
6	anyrange Indikerar att en funktion accepterar alla datatyper i intervallet.
7	cstring Indikerar att en funktion accepterar eller returnerar en C-sträng med nollterminering.
8	internal Anger att en funktion accepterar eller returnerar en serverintern datatyp.
9	language_handler En procedurspråkskallhanterare deklareras för att returnera language_handler.
10	fdw_handler En handläggare av främmande data är deklarerad för att returnera fdw_handler.
11	record Identifierar en funktion som returnerar en ospecificerad radtyp.
12	trigger En triggerfunktion deklareras att returnera trigger.
13	void Indikerar att en funktion inte returnerar något värde.

PostgreSQL – Datatyper