{"canonical_url":"https://engineer.company/nb/glossary/materialized-view/","content_markdown":"# Materialisert visning\n\n## Hva det er\n\nEn materialisert visning er en spørring der databasen tar vare på resultatet,\nslik at en lesing returnerer rader som er regnet ut tidligere, i stedet for å\nkjøre spørringen på nytt. På engelsk heter det materialized view, og det er også\nnavnet kommandoene bruker. Den plasserer seg mellom to eldre objekter. En vanlig\nvisning lagrer bare spørringen sin, og hver lesing kjører den mot tabellene\nunder. En tabell laget med `CREATE TABLE AS` lagrer et resultat, men glemmer\nspørringen som ga det. En materialisert visning beholder begge deler: radene,\nsom lesingene henter fra, og spørringen, som kan kjøres igjen for å erstatte\ndem.\n\nPostgreSQL fikk materialiserte visninger i versjon 9.3, utgitt 9. september\n2013, og utgivelsesnotatene krediterer Kevin Grittner for arbeidet. Ifølge\ndokumentasjonen bruker de regelsystemet på samme måte som vanlige visninger, men\nlagrer resultatet i en tabellignende form. For spørringsparseren er en\nmaterialisert visning en relasjon som enhver tabell eller visning, så en\n`SELECT` mot den leser de lagrede radene direkte; den lagrede spørringen brukes\nbare når visningen skal fylles. Innholdet kan ikke endres direkte. For å erstatte\ninnholdet med et ferskt spørringsresultat må den lagrede spørringen kjøres på\nnytt.\n\nTo kommandoer gjør den jobben. `CREATE MATERIALIZED VIEW` definerer visningen og\nkjører spørringen med en gang for å fylle den, med mindre den får\n`WITH NO DATA`. `REFRESH MATERIALIZED VIEW` kjører den lagrede spørringen igjen\nog erstatter hele innholdet med det nye resultatet. Versjon 9.4, utgitt 18.\ndesember 2014, la til `CONCURRENTLY`, som lar en oppdatering kjøre uten å\nblokkere øktene som leser visningen. Begge kommandoene er PostgreSQL-utvidelser\nog ikke en del av SQL-standarden; andre databaser tilbyr ideen med sin egen\nsyntaks og sine egne regler.\n\n## Hvorfor det er viktig\n\nNoen spørringer er dyre og blir stilt ofte: et dashbord som summerer et års\nordrer per dag, en rapport som joiner seks tabeller, en side som rangerer\nprodukter etter salg. Kjørt mot kildetabellene betaler hver forespørsel for hele\nskanningen, joinen og aggregeringen på nytt, selv om svaret knapt endrer seg fra\nden ene forespørselen til den neste. En materialisert visning betaler den prisen\nén gang per oppdatering, og hver lesing etter det er en skanning av en liten\ntabell som er regnet ut på forhånd. Ifølge PostgreSQL-dokumentasjonen går det\nofte mye raskere å lese de lagrede dataene enn å gå til tabellene under, enten\ndet skjer direkte eller gjennom en visning.\n\nPrisen er ferskhet. Mellom to oppdateringer viser visningen dataene slik de var\nved den siste, og i PostgreSQL oppdaterer ingenting den med mindre noen, eller\nnoe planlagt, ber om det. Mange bruksområder kan leve med det. Gårsdagens salg\nendrer seg ikke i dag, og en månedsrapport trenger ikke ordrene fra siste\nminutt. Det en materialisert visning tvinger frem, er en uttrykkelig beslutning:\nhvor gammelt svaret får være, og hvem som har ansvaret for at det ikke blir\neldre.\n\nDen gir også indekser et sted å bo: det lagrede resultatet kan få sine egne\nindekser, bygget for spørringene som leser det. PostgreSQL-dokumentasjonen viser\nen annen bruk av det samme: data hentet inn fra et annet system gjennom en\nforeign data wrapper, som kanskje ikke støtter indekser i det hele tatt, kan\nkopieres over i en materialisert visning som gjør det.\n\nFor et team som holder skjemaet sitt normalisert, er det ofte her den flate\nformen hører hjemme. Databasenormalisering lagrer hvert faktum ett sted og\nbesvarer de fleste spørsmål gjennom joins. En materialisert visning kan holde\ndet joinede og summerte resultatet som rapporteringen vil ha, mens\nkildetabellene beholder sin ene kopi av hvert faktum, og hver skriving fortsatt\ngår til ett sted.\n\n## Slik ser det ut i praksis\n\nTa ordretabellene til en nettbutikk: `orders`, med én rad per ordre og datoen\nden ble lagt inn, og `order_lines`, med varenummer, antall og enhetspris for\nhver linje. Et salgsdashbord skal vise solgte enheter og omsetning per produkt\nper dag. Spørringen er kort, men over flere års ordrer leser den hver eneste\nlinje:\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`-betingelsen utelater dagen i dag, der tallene fortsatt beveger seg, så\ndashbordet bare viser hele dager; eksempelet i PostgreSQLs egen dokumentasjon\nbehandler en dag med uferdig salg på samme måte. Kommandoen kjører spørringen én\ngang og lagrer resultatet. Deretter kommer en indeks:\n\n```sql\nCREATE UNIQUE INDEX daily_sales_sku_day ON daily_sales (sku, day);\n```\n\nIndeksen har to oppgaver. Den lar dashbordet finne dagene for ett produkt uten å\nlese hele visningen, og det er den som senere gjør en samtidig oppdatering\nmulig. Spørringen grupperer på dag og varenummer, så hvert par forekommer én\ngang, og derfor kan indeksen være unik. Fra nå av leser dashbordet visningen som\nen tabell:\n\n```sql\nSELECT day, units, revenue\nFROM   daily_sales\nWHERE  sku = 'TEA-250'\nORDER  BY day;\n```\n\nHver natt, kort etter midnatt, oppdaterer en planlagt jobb den:\n\n```sql\nREFRESH MATERIALIZED VIEW CONCURRENTLY daily_sales;\n```\n\nUten `CONCURRENTLY` bruker en oppdatering som berører mange rader, gjerne færre\nressurser og blir raskere ferdig, men den kan blokkere lesingene fra dashbordet\ntil den er ferdig. Med `CONCURRENTLY` fortsetter lesingene under oppdateringen,\nog dokumentasjonen påpeker at det til og med kan være det raskeste valget når\nbare få rader endres, som her, der én ny dag kommer til hver natt. Valget har to\nbetingelser. Visningen må allerede inneholde data, og den må ha minst én unik\nindeks bygget av rene kolonnenavn som dekker alle radene, altså ingen\nuttrykksindeks og ingen `WHERE`-betingelse. Indeksen over oppfyller den andre;\nat visningen ble laget med dataene sine, oppfylte den første.\n\nAndre databaser trekker grensen andre steder. I BigQuery blir materialiserte\nvisninger vedlikeholdt i bakgrunnen: endringer i basistabellene legges til\ntrinnvis uten at noen ber om det, en spørring mot visningen fletter inn de siste\nendringene slik at resultatet holder seg ferskt, og smart tuning kan sende en\nspørring som er skrevet mot basistabellene, videre til visningen i stedet. Det\ngjelder inkrementelle visninger, som bare godtar et begrenset utvalg av SQL. En\nvisning definert med `allow_non_incremental_definition = true` godtar de fleste\nspørringer, men hver oppdatering kjører hele spørringen, og resultatene er ikke\nalltid ferske.\n\nSQL Server når et lignende resultat med indekserte visninger. Lager man en unik\nclustered indeks på en visning, som må være laget `WITH SCHEMABINDING` og ha en\ndeterministisk definisjon, lagres resultatet på samme måte som en tabell med en\nclustered indeks, og spørringsoptimalisereren kan bruke den, også for en\nspørring som ikke nevner visningen. SQL Server oppdaterer den indekserte\nvisningen sammen med hver insert, update og delete på tabellene den er avhengig\nav, så det finnes ingen oppdatering å planlegge; kostnaden flytter over på\nskrivingene, og dokumentasjonen fra Microsoft advarer om at ytelsen deres kan\nfalle betydelig.\n\nDen samme avveiningen viser seg i produksjonsarbeid. I en tidligere rolle utviklet\ngrunnleggeren [ETL/ELT-pipelines i PL/pgSQL](/nb/portfolio/engineered-600-pl-pgsql-etl-elt-pipelines/), som\ntok i bruk partisjonerte tabeller og materialiserte visninger for å optimalisere\nleseytelsen for store datasett, sammen med primær- og fremmednøkkelbegrensninger\nfor referanseintegriteten og unike og sammensatte indekser for\nJOIN-operasjonene.\n\n## Hvor det går galt\n\n**Gamle tall som ser ferske ut.** En oppdateringsjobb som sluttet å kjøre for en\nuke siden, etterlater en visning som svarer på hver spørring, raskt og feil, og\ningenting i resultatet forteller hvor gammelt det er. La jobben registrere\ntidspunktet for hver vellykket oppdatering et sted der dashbordet kan vise det,\nog send et varsel når tidspunktet er eldre enn leserne har godtatt.\n\n**En oppdatering som blokkerer leserne.** En vanlig `REFRESH MATERIALIZED VIEW`\nover en stor visning kan blokkere alle økter som prøver å lese den, til\noppdateringen er ferdig. Legg til en unik indeks og bruk `CONCURRENTLY`, eller\nlegg de vanlige oppdateringene til timer da ingen leser visningen. Når de fleste\nradene endres ved hver kjøring, kan den vanlige oppdateringen likevel være den\nbilligste.\n\n**`CONCURRENTLY` blir avvist.** Valget krever en unik indeks på rene kolonner\nsom dekker alle radene. En unik indeks på `lower(email)`, eller en som er\navgrenset av en `WHERE`-betingelse, holder ikke. Det krever også en visning som\nallerede inneholder data, så det feiler på en visning laget `WITH NO DATA`, og\nde to valgene kan ikke kombineres. Legg til en indeks som oppfyller kravene, og\nfyll visningen én gang med en vanlig oppdatering.\n\n**En visning som ikke kan skannes.** `WITH NO DATA` lager visningen uten å kjøre\nspørringen og merker den som ikke skannbar, og enhver spørring mot den feiler\nfrem til den første oppdateringen. Det kan være riktig valg i en migrering som\nikke skal vente på en lang spørring, men da må den første oppdateringen\nplanlegges, ikke glemmes.\n\n**En endret definisjon som aldri kom frem.**\n`CREATE MATERIALIZED VIEW IF NOT EXISTS` i en migrering gjør ingenting utover å\ngi en notice når en visning med det navnet allerede finnes, og dokumentasjonen\ngir ingen garanti for at den eksisterende visningen ligner den nye definisjonen.\nEn migrering som endrer spørringen på den måten, lar den gamle bli stående.\nFjern visningen med `DROP MATERIALIZED VIEW`, og lag den på nytt i samme\nmigrering.\n\n**Oppdateringsjobber som overlapper.** Bare én oppdatering om gangen kan kjøre\nmot en gitt materialisert visning, også med `CONCURRENTLY`, så en tidsplan som\ner tettere enn selve oppdateringen, etterlater visningen bare lenger bak. Mål\nhvor lang tid en oppdatering tar, og legg tidsplanen ut fra det.\n\n**Å stole på rekkefølgen til radene.** Har den definerende spørringen en\n`ORDER BY`, kommer det første innholdet i den rekkefølgen, men en oppdatering\nlover ikke å beholde den. Sett `ORDER BY` i spørringene som leser visningen.\n\n**Funksjoner som mister tabellene sine.** Mens den definerende spørringen\nkjører, ved opprettelsen eller ved en oppdatering, setter PostgreSQL\n`search_path` midlertidig til `pg_catalog, pg_temp` og begrenser hva spørringen\nfår gjøre: en funksjon som lager midlertidige tabeller, feiler. En funksjon som\nfinner tabellene sine ved et ukvalifisert navn, kan bestå hver test for hånd og\nførst knekke inne i oppdateringen. Kvalifiser tabellnavnene med skjemaet i alle\nfunksjoner visningen kaller.\n\n**Feil rolle kjører jobben.** En oppdatering krever privilegiet `MAINTAIN` på\nden materialiserte visningen. En jobb som kjører som en rapporteringsrolle som\nfår lese visningen, men ikke vedlikeholde den, feiler hver natt. Gi rollen som\nkjører oppdateringen, det privilegiet.\n\n**En lagret kopi der en indeks ville holdt.** Er en spørring treg fordi en\nindeks mangler, skjuler en materialisert visning problemet og legger gamle data\npå toppen. Les spørringsplanen først. Når en spørring bare trenger et navn,\nholder en vanlig visning, og den er alltid oppdatert; spar materialiserte\nvisninger til resultater som er dyre å regne ut og trygge å lese litt gamle.\n\n## Les mer\n\n- [Materialized Views](https://www.postgresql.org/docs/current/rules-materializedviews.html)\n  — kapittelet i PostgreSQL-manualen om hvordan materialiserte visninger\n  forholder seg til visninger og tabeller, med en salgsoversikt som oppdateres\n  hver natt og et eksempel med en foreign data wrapper.\n- [CREATE MATERIALIZED VIEW](https://www.postgresql.org/docs/current/sql-creatematerializedview.html)\n  — kommandoreferansen, blant annet `WITH NO DATA`, `IF NOT EXISTS` og den\n  begrensede `search_path` mens spørringen kjører.\n- [REFRESH MATERIALIZED VIEW](https://www.postgresql.org/docs/current/sql-refreshmaterializedview.html)\n  — oppdateringskommandoen, betingelsene for `CONCURRENTLY` og privilegiet\n  `MAINTAIN` som den krever.\n- [PostgreSQL 9.3 release notes](https://www.postgresql.org/docs/9.3/release-9-3.html)\n  — utgivelsen fra september 2013 som la til materialiserte visninger.\n- [Introduction to materialized views](https://cloud.google.com/bigquery/docs/materialized-views-intro)\n  — inkrementelle og ikke-inkrementelle materialiserte visninger i BigQuery,\n  automatisk oppdatering og smart tuning.\n- [Create indexed views](https://learn.microsoft.com/en-us/sql/relational-databases/views/create-indexed-views)\n  — indekserte visninger i SQL Server, kravene til dem og hva de koster for\n  skrivingene.\n\n\u003chttps://engineer.company/nb/glossary/materialized-view/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hva en materialisert visning er: et lagret spørringsresultat i PostgreSQL, REFRESH og CONCURRENTLY, BigQuery og SQL Server, og hvor det går galt.","formats":{"gemtext":"https://engineer.company/nb/glossary/materialized-view/index.gmi","gopher":"https://engineer.company/nb/glossary/materialized-view/gophermap","html":"https://engineer.company/nb/glossary/materialized-view/","json":"https://engineer.company/nb/glossary/materialized-view/index.json","markdown":"https://engineer.company/nb/glossary/materialized-view/index.md","pdf":"https://engineer.company/nb/glossary/materialized-view/index.pdf"},"kind":"page","language":"nb","title":"Hva er en materialisert visning?","url":"https://engineer.company/nb/glossary/materialized-view/","version":1}