{"canonical_url":"https://engineer.company/sv/glossary/schema/","content_markdown":"# Databasschema\n\n## Vad det är\n\nEtt databasschema, i dagligt tal bara schema, är en namnrymd inuti en databas:\nen behållare för tabeller, vyer, datatyper, funktioner och operatorer, så att\nsamma namn kan användas i två scheman utan att de krockar. PostgreSQL-manualen\njämför scheman med kataloger i ett filsystem, med skillnaden att de inte kan\nnästlas: en databas rymmer scheman, och scheman rymmer objekt. Ordet har också\nen andra, lösare betydelse som är minst lika vanlig: en databas schema är hela\ndess struktur, varje tabell, kolumn, nyckel och villkor. Båda betydelserna\nförekommer nedan, och pluralformen scheman syftar nästan alltid på\nnamnrymderna.\n\nEn faktureringsdel av en applikation kan bo i ett eget schema, och en session\nkan välja vilka scheman den letar i:\n\n```sql\nCREATE SCHEMA billing;\n\nCREATE TABLE billing.invoices (\n  id     bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,\n  total  numeric(12, 2) NOT NULL\n);\n\nSHOW search_path;                  -- \"$user\", public\nSET search_path = billing, public;\nSELECT count(*) FROM invoices;     -- pekar nu på billing.invoices\n```\n\nEtt namn som skrivs med sitt schema, som `billing.invoices`, betyder alltid\nsamma tabell. Ett namn utan schema slås upp via search_path, en lista med\nscheman som servern går igenom i ordning tills den hittar en träff.\nStandardlistan är `\"$user\", public`: först ett schema med samma namn som den\nroll sessionen kör som, om ett sådant finns, sedan schemat public som varje ny\ndatabas börjar med. Det första existerande schemat i sökvägen är också där\nCREATE TABLE lägger en tabell vars namn saknar schema, och därför hamnar objekt\ni public om ingen säger något annat. Ett namn som inte finns i något av de\nlistade schemana ger ett fel, även om ett annat schema i samma databas har det.\n\n## Varför det spelar roll\n\nOrdning är det första skälet. En databas med några hundra tabeller behöver en\nnivå ovanför tabellen, och scheman ger den: fakturering i ett, konton i ett\nannat, ett tredjepartsverktygs tabeller i ett tredje, på behörigt avstånd från\nalla andras namn. En klientanslutning når en enda databas, men scheman är inte\nstrikt åtskilda: en roll kan använda objekt i vilket schema som helst i den\ndatabas den är ansluten till, om privilegierna tillåter det, och en SQL-fråga\nkan joina tabeller från flera av dem.\n\nÅtkomstkontroll är det andra. USAGE på ett schema låter en roll slå upp\nobjekten i det, och CREATE låter den lägga till nya. Tas USAGE bort spärras\nåtkomsten till objekten, men deras namn går fortfarande att läsa i\nsystemkatalogerna, så ett schema skyddar datan men inte vetskapen om vad som\nfinns. `CREATE SCHEMA name AUTHORIZATION role` lämnar över ett nytt schema till\nen roll, och namn som börjar med `pg_` är reserverade för systemet.\n\nDet tredje skälet är säkerhet, eftersom scheman deltar i namnuppslagningen. De\nflesta namn i SQL-frågor skrivs utan schema, och därför innebär det, med\nmanualens ord, att lägga till ett schema i search_path i praktiken att lita på\nvarje roll som kan skapa objekt i det. En sådan roll kan få en helt vanlig\nSQL-fråga att köra funktioner som rollen själv har valt, som om den som körde\nfrågan hade anropat dem. De säkra mönstren håller scheman som andra kan skriva i\nborta från användarens sökväg, t.ex. ett privat schema per användare, skapat med\n`CREATE SCHEMA alice AUTHORIZATION alice`, som posten `\"$user\"` sedan hittar\nförst. PostgreSQL 15 flyttade nya databaser åt det hållet: versionen tog bort\nrätten för varje roll att skapa objekt i public och gjorde databasägaren, via\nrollen pg_database_owner, till ägare av public.\n\nPortabilitet är den sista punkten. SQL-standarden har scheman men inget\npublic-schema, och manualen påpekar att vissa SQL-system kanske inte\nimplementerar scheman alls. Kvalificerade namn flyttar lättare mellan system än\nkod som lutar sig mot search_path.\n\n## Så ser det ut i praktiken\n\nDatamodellen bakom\n[348 tabeller i 34 Postgres-scheman](/sv/portfolio/modeled-348-tables-across-34-postgres-schemas/)\nanvänder scheman i den första betydelsen, som nivån ovanför tabellen.\nSjöfartsdomänen, med yrkesverksamma, företag, fartyg, jobb och recensioner, är\nuppbyggd som normaliserade PostgreSQL-scheman organiserade per domän: 348\ntabeller fördelade på 34 av dem. Tabellnamnen står i plural inuti scheman med\nnamn i singular, utan undantag, vilket också undviker en mängd kollisioner med\nreserverade ord, och riktiga främmande nycklar och villkor håller ihop\nrelationerna. Att lägga till en funktion innebär oftast att schemat byggs ut\nlängs de befintliga linjerna i stället för mot dem, och enligt sidan är det\nenda skälet till att 34 scheman blir en struktur och inte ett virrvarr.\n\nEtt schema kan också vara gränsen mellan två uppgifter. I\n[åtkomsträttigheter via Stripe och appköp](/sv/portfolio/built-stripe-and-in-app-purchase-entitlements/)\nstrålar kortbetalningar via Stripe och köp i appen hos Apple och Google samman i\nett betalningsschema med 9 tabeller och 34 funktioner. Ett separat\nåtkomstschema med 11 tabeller och 34 funktioner svarar på ”får det här kontot\ngöra det här?” utan att veta vilken försäljningskanal som betalade. Servern\nhämtar svaret ur åtkomstschemat på nytt för varje anrop, och det styr åtkomsten\ntill företagskatalogen, sökningen och dataexporten. Kostnaden är enligt sidan\ntvå scheman där en mindre produkt skulle nöja sig med ett, plus ett\nbehörighetsuppslag på anrop som annars hade varit gratis.\n\nDen andra betydelsen av ordet är ämnet för\n[1 022 migreringar bakom en grind mot schemadrift](/sv/portfolio/1022-migrations-behind-a-schema-drift-gate/).\nDe flesta projekt beskriver ett schema två gånger, i den initiala uppsättningen\nsom bygger det från grunden och i de databasmigreringar som har fått det att\nväxa, och de två glider isär om inget kontrollerar dem. Här har schemat vuxit\nmigrering för migrering, från nummer 036 till 1102, och ett CI-jobb bygger det\ntvå gånger vid varje ändring, en gång från grunden och en gång med alla\nmigreringar körda i ordning, och jämför sedan de två: grunddatan lika väl som\nstrukturen. En migrering som i efterhand fyller i en uppslagstabell fel gör lika\nmycket skada som en som glömmer en kolumn, och bara den ena syns i en\nschemadiff. Varje avvikelse fäller bygget med skillnaden utskriven, så varje\nmigrering måste fungera både när den spelas upp i ordning och från noll.\n\n## Var det går fel\n\n**En funktion planterad i ett delat schema.** PostgreSQL-wikins guide till\nCVE-2018-1058 visar attacken: en användare skapar `lower(varchar)` i public.\nDen inbyggda `lower` ligger i pg_catalog och tar text, så för en\nvarchar-kolumn är den planterade funktionen den närmare träffen, och en kollega\nsom kör `SELECT lower(full_name) FROM a` kör den planterade koden i stället.\nKvalificera anrop i känslig kod som `pg_catalog.lower`, ta bort CREATE på\npublic från de roller som inte behöver det och lista det som redan finns där\nmed `\\df public.*`.\n\n**En uppgradering som behöll de gamla rättigheterna.** Den säkrare standarden i\nPostgreSQL 15 gäller nya kluster och nyskapade databaser. En uppgradering av ett\nkluster eller en återställd dump bevarar de rättigheter som public redan hade,\nså en server på version 15 eller senare kan fortfarande låta varje roll skapa\nobjekt där. Manualen kallar standardsökvägen med CREATE beviljat på public för\nett mönster som aldrig är säkert, och påpekar att det är standard i databaser\nsom har uppgraderats från 14 eller tidigare. Kör i en sådan databas\n`REVOKE CREATE ON SCHEMA public FROM PUBLIC` och granska sedan public efter\nobjekt med samma namn som de i pg_catalog.\n\n**En tabell som skapas på fel ställe.** En databasmigrering skapar `invoices`\nutan schema, och tabellen hamnar i det första existerande schemat på sökvägen\nför den roll som kör den. Applikationen, som ansluter med en annan sökväg,\nläser sedan en annan tabell eller får `relation \"invoices\" does not exist`.\nKvalificera varje namn i migreringar och kontrollera `SELECT current_schema()`\ni den session som kör dem.\n\n**En DROP som når förbi schemat.** `DROP SCHEMA billing` vägrar så länge\nschemat innehåller något, eftersom RESTRICT är standard. Med CASCADE tas varje\nobjekt i schemat bort, liksom varje objekt som beror på dem, och manualen\nvarnar för att det kan ta bort objekt i andra scheman än det som nämndes.\nRådet är att först köra DROP utan CASCADE och läsa DETAIL-raderna, som listar\nvad som skulle försvinna.\n\n**Ett namn som systemet slår upp först.** När pg_catalog inte anges i\nsearch_path söker systemet implicit där före schemana som räknas upp i sökvägen.\nOm det anges uttryckligen bestämmer dess plats i sökvägen sökordningen. En egen\ntabell vars namn börjar med `pg_` kan skuggas när en senare version lägger till\nen systemtabell med samma namn, så manualen avråder från sådana namn.\nReserverade ord som `user` och `order` ger en mildare variant av samma problem:\nen tabell med ett sådant namn behöver dubbla citattecken i varje sats.\n\n## Läs mer\n\n- [5.10. Schemas](https://www.postgresql.org/docs/current/ddl-schemas.html)\n  — manualens kapitel: kvalificerade namn, schemat public, search_path, säkra\n  användningsmönster och portabilitet.\n- [CREATE SCHEMA](https://www.postgresql.org/docs/current/sql-createschema.html)\n  — kommandots syntax, AUTHORIZATION-satsen, det reserverade prefixet `pg_` och\n  var PostgreSQL avviker från standarden.\n- [5.8. Privileges](https://www.postgresql.org/docs/current/ddl-priv.html)\n  — vad USAGE och CREATE betyder på ett schema, bredvid alla andra privilegier.\n- [E.20. Release 15](https://www.postgresql.org/docs/15/release-15.html)\n  — versionen som tog bort CREATE på public från nya databaser och behöll det\n  för uppgraderade.\n- [A Guide to CVE-2018-1058: Protect Your Search Path](https://wiki.postgresql.org/wiki/A_Guide_to_CVE-2018-1058%3A_Protect_Your_Search_Path)\n  — projektets genomgång av attacken med planterade funktioner, med åtgärderna\n  och kommandona för att granska en databas.\n\n\u003chttps://engineer.company/sv/glossary/schema/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"För dig som designar eller förvaltar PostgreSQL: hur search_path väljer tabell, varför schemat public bör låsas och var scheman ställer till det.","formats":{"gemtext":"https://engineer.company/sv/glossary/schema/index.gmi","gopher":"https://engineer.company/sv/glossary/schema/gophermap","html":"https://engineer.company/sv/glossary/schema/","json":"https://engineer.company/sv/glossary/schema/index.json","markdown":"https://engineer.company/sv/glossary/schema/index.md","pdf":"https://engineer.company/sv/glossary/schema/index.pdf"},"kind":"page","language":"sv","title":"Vad är ett databasschema?","url":"https://engineer.company/sv/glossary/schema/","version":1}