{"canonical_url":"https://engineer.company/sv/glossary/materialized-view/","content_markdown":"# Materialiserad vy\n\n## Vad det är\n\nEn materialiserad vy är en fråga vars resultat databasen sparar, så att en\nläsning returnerar rader som räknats fram tidigare i stället för att köra frågan\npå nytt. På engelska heter den materialized view, och det är också namnet som\nkommandona använder. Den har sin plats mellan två äldre objekt. En vanlig vy\nlagrar bara sin fråga, och varje läsning kör den mot tabellerna därunder. En\ntabell som skapats med `CREATE TABLE AS` lagrar ett resultat men glömmer frågan\nsom gav det. En materialiserad vy behåller båda: raderna, som läsningarna hämtar\nfrån, och frågan, som kan köras igen för att ersätta dem.\n\nPostgreSQL fick materialiserade vyer i version 9.3, som släpptes den 9 september\n2013, och versionsanteckningarna krediterar Kevin Grittner för arbetet. Enligt\ndokumentationen använder de regelsystemet på samma sätt som vanliga vyer men\nlagrar resultatet i en tabellik form. För frågeparsern är en materialiserad vy\nen relation som vilken tabell eller vy som helst, så en `SELECT` mot den läser\nde lagrade raderna direkt; den lagrade frågan används bara när vyn ska fyllas.\nInnehållet kan inte ändras direkt. För att ersätta innehållet med ett nytt frågeresultat måste den\nlagrade frågan köras igen.\n\nTvå kommandon sköter det arbetet. `CREATE MATERIALIZED VIEW` definierar vyn och\nkör frågan på en gång för att fylla den, om den inte får `WITH NO DATA`.\n`REFRESH MATERIALIZED VIEW` kör den lagrade frågan igen och ersätter hela\ninnehållet med det nya resultatet. Version 9.4, som släpptes den 18 december\n2014, lade till `CONCURRENTLY`, som låter en uppdatering köras utan att blockera\nde sessioner som läser vyn. Båda kommandona är PostgreSQL-tillägg och inte en\ndel av SQL-standarden; andra databaser erbjuder idén med sin egen syntax och\nsina egna regler.\n\n## Varför det spelar roll\n\nVissa frågor är dyra och ställs ofta: en dashboard som summerar ett års ordrar\nper dag, en rapport som joinar sex tabeller, en sida som rangordnar produkter\nefter försäljning. Körd mot källtabellerna betalar varje anrop för hela\ngenomsökningen, joinen och aggregeringen igen, fast svaret knappt rör sig från\nett anrop till nästa. En materialiserad vy betalar det priset en gång per\nuppdatering, och varje läsning därefter är en genomsökning av en liten tabell\nsom räknats fram i förväg. Enligt PostgreSQL-dokumentationen går det ofta mycket\nsnabbare att läsa de lagrade data än att gå till tabellerna därunder, vare sig\ndet sker direkt eller via en vy.\n\nPriset är aktualitet. Mellan två uppdateringar visar vyn data som de såg ut vid\nden senaste, och i PostgreSQL uppdaterar ingenting den om inte någon, eller\nnågot schemalagt, ber om det. Många användningar klarar sig med det. Gårdagens\nförsäljning ändras inte i dag, och en månadsrapport behöver inte ordrarna från\nden senaste minuten. Det som en materialiserad vy tvingar fram är ett\nuttryckligt beslut: hur gammalt svaret får vara, och vems uppgift det är att\nhindra det från att bli äldre.\n\nDen ger också index en plats att bo på: det lagrade resultatet kan få egna\nindex, byggda för de frågor som läser det. PostgreSQL-dokumentationen visar en\nannan användning av samma sak: data som hämtas in från ett annat system via en\nforeign data wrapper, som kanske inte stöder index alls, kan kopieras över till\nen materialiserad vy som gör det.\n\nFör ett team som håller sitt schema normaliserat är det ofta här den platta\nformen hör hemma. Databasnormalisering lagrar varje uppgift på ett ställe och\nbesvarar de flesta frågor med joins. En materialiserad vy kan hålla det joinade\noch summerade resultatet som rapporteringen vill ha, medan källtabellerna\nbehåller sin enda kopia av varje uppgift och varje skrivning fortfarande går\ntill ett ställe.\n\n## Så ser det ut i praktiken\n\nTa en webbutiks ordertabeller: `orders`, med en rad per order och datumet då den\nlades, och `order_lines`, med artikelnummer, antal och styckpris för varje rad.\nEn försäljningsdashboard ska visa sålda enheter och intäkter per produkt och\ndag. Frågan är kort, men över flera års ordrar läser den varenda rad:\n\n```sql\nCREATE MATERIALIZED VIEW daily_sales AS\nSELECT o.ordered_on                   AS day,\n       l.sku,\n       sum(l.quantity)                AS units,\n       sum(l.quantity * l.unit_price) AS revenue\nFROM   orders o\nJOIN   order_lines l USING (order_id)\nWHERE  o.ordered_on \u003c CURRENT_DATE\nGROUP  BY o.ordered_on, l.sku;\n```\n\n`WHERE`-villkoret utesluter dagens försäljning, vars siffror fortfarande ändras, så\natt dashboarden bara visar hela dagar; exemplet i PostgreSQL:s egen\ndokumentation behandlar en dag med ofullständig försäljning på samma sätt.\nKommandot kör frågan en gång och lagrar resultatet. Sedan kommer ett index:\n\n```sql\nCREATE UNIQUE INDEX daily_sales_sku_day ON daily_sales (sku, day);\n```\n\nIndexet har två uppgifter. Det låter dashboarden hitta en produkts dagar utan\natt läsa hela vyn, och det är det som senare gör en samtidig uppdatering möjlig.\nFrågan grupperar på dag och artikelnummer, så varje par förekommer en gång, och\ndärför kan indexet vara unikt. Från och med nu läser dashboarden vyn som en\ntabell:\n\n```sql\nSELECT day, units, revenue\nFROM   daily_sales\nWHERE  sku = 'TEA-250'\nORDER  BY day;\n```\n\nVarje natt, strax efter midnatt, uppdaterar ett schemalagt jobb den:\n\n```sql\nREFRESH MATERIALIZED VIEW CONCURRENTLY daily_sales;\n```\n\nUtan `CONCURRENTLY` använder en uppdatering som berör många rader oftast mindre\nresurser och blir klar snabbare, men den kan blockera dashboardens läsningar\ntills den är klar. Med `CONCURRENTLY` fortsätter läsningarna under\nuppdateringen, och dokumentationen påpekar att det till och med kan vara det\nsnabbare valet när bara få rader ändras, som här, där en ny dag tillkommer varje\nnatt. Valet har två villkor. Vyn måste redan innehålla data, och den måste ha\nminst ett unikt index byggt av rena kolumnnamn som täcker alla rader, alltså\ninget uttrycksindex och inget `WHERE`-villkor. Indexet ovan uppfyller det andra;\natt vyn skapades med sina data uppfyllde det första.\n\nAndra databaser drar gränsen på andra ställen. I BigQuery underhålls\nmaterialiserade vyer i bakgrunden: ändringar i bastabellerna läggs till\ninkrementellt utan att någon ber om det, en fråga mot vyn fogar in de senaste\nändringarna så att resultatet förblir aktuellt, och smart tuning kan skicka en\nfråga som skrivits mot bastabellerna vidare till vyn i stället. Det gäller\ninkrementella vyer, som bara godtar en begränsad del av SQL. En vy som\ndefinierats med `allow_non_incremental_definition = true` godtar de flesta\nfrågor, men varje uppdatering kör hela frågan, och resultaten är inte alltid\naktuella.\n\nSQL Server når ett liknande resultat med indexerade vyer. Skapar man ett unikt\nklustrat index på en vy, som måste vara skapad `WITH SCHEMABINDING` och ha en\ndeterministisk definition, lagras resultatet på samma sätt som en tabell med ett\nklustrat index, och frågeoptimeraren kan använda det även för en fråga som inte\nnämner vyn. SQL Server uppdaterar den indexerade vyn tillsammans med varje\ninsert, update och delete i de tabeller den är beroende av, så det finns ingen\nuppdatering att schemalägga; kostnaden flyttar till skrivningarna, och\nMicrosofts dokumentation varnar för att deras prestanda kan försämras avsevärt.\n\nSamma avvägning syns i produktionsarbete. I en tidigare roll utvecklade grundaren\n[ETL/ELT-pipelines i PL/pgSQL](/sv/portfolio/engineered-600-pl-pgsql-etl-elt-pipelines/), som\nutnyttjade partitionerade tabeller och materialiserade vyer för att optimera\nläsprestandan för stora datamängder, tillsammans med villkor för primärnycklar\noch främmande nycklar för referensintegriteten och unika och sammansatta index\nför JOIN-operationerna.\n\n## Var det går fel\n\n**Gamla siffror som ser aktuella ut.** Ett uppdateringsjobb som slutade köras\nför en vecka sedan lämnar kvar en vy som besvarar varje fråga, snabbt och fel,\noch ingenting i resultatet säger hur gammalt det är. Låt jobbet registrera tiden\nför varje lyckad uppdatering någonstans där dashboarden kan visa den, och larma\nnär den tiden är äldre än läsarna har godtagit.\n\n**En uppdatering som blockerar läsarna.** En vanlig `REFRESH MATERIALIZED VIEW`\növer en stor vy kan blockera alla sessioner som försöker läsa den tills\nuppdateringen är klar. Lägg till ett unikt index och använd `CONCURRENTLY`,\neller lägg de vanliga uppdateringarna till timmar då ingen läser vyn. När de\nflesta rader ändras vid varje körning kan den vanliga uppdateringen ändå vara\nden billigaste.\n\n**`CONCURRENTLY` avvisas.** Valet kräver ett unikt index på rena kolumner som\ntäcker alla rader. Ett unikt index på `lower(email)`, eller ett som begränsas av\nett `WHERE`-villkor, duger inte. Det kräver också en vy som redan innehåller\ndata, så det misslyckas på en vy som skapats `WITH NO DATA`, och de två valen\nkan inte kombineras. Lägg till ett index som uppfyller kraven, och fyll vyn en\ngång med en vanlig uppdatering.\n\n**En vy som inte går att läsa.** `WITH NO DATA` skapar vyn utan att köra frågan\noch markerar den som oläsbar, och varje fråga mot den misslyckas fram till den\nförsta uppdateringen. Det kan vara rätt val i en migrering som inte ska vänta på\nen lång fråga, men då måste den första uppdateringen planeras, inte glömmas.\n\n**En ändrad definition som aldrig kom fram.**\n`CREATE MATERIALIZED VIEW IF NOT EXISTS` i en migrering gör ingenting utöver att\nge en notice när en vy med det namnet redan finns, och dokumentationen ger ingen\ngaranti för att den befintliga vyn liknar den nya definitionen. En migrering som\nändrar frågan på det sättet låter den gamla stå kvar. Ta bort vyn med\n`DROP MATERIALIZED VIEW`, och skapa den igen i samma migrering.\n\n**Uppdateringsjobb som överlappar.** Bara en uppdatering i taget kan köras mot\nen given materialiserad vy, även med `CONCURRENTLY`, så ett schema som är tätare\nän själva uppdateringen lämnar bara vyn längre efter. Mät hur lång tid en\nuppdatering tar, och schemalägg utifrån det.\n\n**Att lita på radernas ordning.** Har den definierande frågan en `ORDER BY`\nkommer det första innehållet i den ordningen, men en uppdatering lovar inte att\nbehålla den. Lägg `ORDER BY` i de frågor som läser vyn.\n\n**Funktioner som tappar bort sina tabeller.** Medan den definierande frågan\nkörs, när vyn skapas eller vid en uppdatering, sätter PostgreSQL tillfälligt\n`search_path` till `pg_catalog, pg_temp` och begränsar vad frågan får göra: en\nfunktion som skapar temporära tabeller misslyckas. En funktion som hittar sina\ntabeller via ett okvalificerat namn kan klara varje test för hand och gå sönder\nförst inne i uppdateringen. Kvalificera tabellnamnen med schemat i alla\nfunktioner som vyn anropar.\n\n**Fel roll kör jobbet.** En uppdatering kräver behörigheten `MAINTAIN` på den\nmaterialiserade vyn. Ett jobb som körs under en rapportroll med rätt att läsa\nvyn men inte att underhålla den misslyckas varje natt. Ge den roll som kör\nuppdateringen den behörigheten.\n\n**En lagrad kopia där ett index hade räckt.** Är en fråga långsam för att ett\nindex saknas döljer en materialiserad vy problemet och lägger gamla data ovanpå.\nLäs frågeplanen först. När en fråga bara behöver ett namn räcker en vanlig vy,\noch den är alltid aktuell; spara materialiserade vyer till resultat som är dyra\natt räkna fram och ofarliga att läsa lite gamla.\n\n## Läs mer\n\n- [Materialized Views](https://www.postgresql.org/docs/current/rules-materializedviews.html)\n  — kapitlet i PostgreSQL-manualen om hur materialiserade vyer förhåller sig\n  till vyer och tabeller, med en försäljningssammanställning som uppdateras\n  varje natt och ett exempel med en foreign data wrapper.\n- [CREATE MATERIALIZED VIEW](https://www.postgresql.org/docs/current/sql-creatematerializedview.html)\n  — kommandoreferensen, bland annat `WITH NO DATA`, `IF NOT EXISTS` och den\n  begränsade `search_path` medan frågan körs.\n- [REFRESH MATERIALIZED VIEW](https://www.postgresql.org/docs/current/sql-refreshmaterializedview.html)\n  — uppdateringskommandot, villkoren för `CONCURRENTLY` och behörigheten\n  `MAINTAIN` som det kräver.\n- [PostgreSQL 9.3 release notes](https://www.postgresql.org/docs/9.3/release-9-3.html)\n  — versionen från september 2013 som lade till materialiserade vyer.\n- [Introduction to materialized views](https://cloud.google.com/bigquery/docs/materialized-views-intro)\n  — inkrementella och icke-inkrementella materialiserade vyer i BigQuery,\n  automatisk uppdatering och smart tuning.\n- [Create indexed views](https://learn.microsoft.com/en-us/sql/relational-databases/views/create-indexed-views)\n  — indexerade vyer i SQL Server, kraven på dem och vad de kostar för\n  skrivningarna.\n\n\u003chttps://engineer.company/sv/glossary/materialized-view/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Vad en materialiserad vy är: ett lagrat frågeresultat i PostgreSQL, REFRESH och CONCURRENTLY, BigQuery och SQL Server, och var det går fel.","formats":{"gemtext":"https://engineer.company/sv/glossary/materialized-view/index.gmi","gopher":"https://engineer.company/sv/glossary/materialized-view/gophermap","html":"https://engineer.company/sv/glossary/materialized-view/","json":"https://engineer.company/sv/glossary/materialized-view/index.json","markdown":"https://engineer.company/sv/glossary/materialized-view/index.md","pdf":"https://engineer.company/sv/glossary/materialized-view/index.pdf"},"kind":"page","language":"sv","title":"Vad är en materialiserad vy?","url":"https://engineer.company/sv/glossary/materialized-view/","version":1}