{"canonical_url":"https://engineer.company/da/glossary/materialized-view/","content_markdown":"# Materialiseret view\n\n## Hvad det er\n\nEt materialiseret view er en forespørgsel, hvis resultat databasen gemmer, så en\nlæsning returnerer rækker, der er beregnet tidligere, i stedet for at køre\nforespørgslen igen. På engelsk hedder det materialized view, og det er også det\nnavn, kommandoerne bærer. Det placerer sig mellem to ældre objekter. Et\nalmindeligt view gemmer kun sin forespørgsel, og hver læsning kører den mod\ntabellerne nedenunder. En tabel oprettet med `CREATE TABLE AS` gemmer et\nresultat, men glemmer den forespørgsel, der skabte det. Et materialiseret view\nbeholder begge dele: rækkerne, som læsningerne kommer fra, og forespørgslen, som\nkan køres igen for at erstatte dem.\n\nPostgreSQL fik materialiserede views i version 9.3, udgivet 9. september 2013,\nog udgivelsesnoterne krediterer Kevin Grittner for arbejdet. Ifølge\ndokumentationen bruger de regelsystemet på samme måde som almindelige views, men\ngemmer resultatet i en tabellignende form. For forespørgselsparseren er et\nmaterialiseret view en relation som enhver tabel eller ethvert view, så en\n`SELECT` mod det læser de gemte rækker direkte; den gemte forespørgsel bruges\nkun, når viewet skal fyldes. Selve indholdet kan ikke ændres direkte. For at erstatte\nindholdet med et nyt forespørgselsresultat skal den gemte forespørgsel køres igen.\n\nTo kommandoer klarer det arbejde. `CREATE MATERIALIZED VIEW` definerer viewet og\nkører straks forespørgslen for at fylde det, medmindre den får `WITH NO DATA`\nmed. `REFRESH MATERIALIZED VIEW` kører den gemte forespørgsel igen og erstatter\nhele indholdet med det nye resultat. Version 9.4, udgivet 18. december 2014,\ntilføjede `CONCURRENTLY`, som lader en opdatering køre uden at blokere de\nsessioner, der læser viewet. Begge kommandoer er PostgreSQL-udvidelser og ikke\nen del af SQL-standarden; andre databaser tilbyder idéen med deres egen syntaks\nog deres egne regler.\n\n## Hvorfor det betyder noget\n\nNogle forespørgsler er dyre og bliver stillet ofte: et dashboard, der summerer\net års ordrer pr. dag, en rapport, der joiner seks tabeller, en side, der\nrangerer produkter efter salg. Kørt mod kildetabellerne betaler hver anmodning\nfor hele scanningen, joinen og aggregeringen igen, selv om svaret knap flytter\nsig fra den ene anmodning til den næste. Et materialiseret view betaler den pris\nén gang pr. opdatering, og hver læsning derefter er en scanning af en lille\ntabel, der er beregnet på forhånd. Ifølge PostgreSQL-dokumentationen er det ofte\nmeget hurtigere at læse de gemte data end at gå til de underliggende tabeller,\nhvad enten det sker direkte eller gennem et view.\n\nPrisen er aktualitet. Mellem to opdateringer viser viewet data, som de så ud ved\nden seneste, og i PostgreSQL opdaterer intet det, medmindre nogen, eller noget\nplanlagt, beder om det. Mange anvendelser kan leve med det. Gårsdagens salg\nændrer sig ikke i dag, og en månedsrapport har ikke brug for ordrerne fra det\nseneste minut. Det, et materialiseret view tvinger frem, er en udtrykkelig\nbeslutning: hvor gammelt svaret må være, og hvis opgave det er at forhindre, at\ndet bliver ældre.\n\nDet giver også indekser et sted at bo: det gemte resultat kan få sine egne\nindekser, bygget til de forespørgsler, der læser det. PostgreSQL-dokumentationen\nviser en anden anvendelse af det samme: data hentet ind fra et andet system\ngennem en foreign data wrapper, som måske slet ikke understøtter indekser, kan\nkopieres over i et materialiseret view, der gør.\n\nFor et team, der holder sit skema normaliseret, er det ofte her, den flade form\nhører hjemme. Databasenormalisering gemmer hver oplysning ét sted og besvarer de\nfleste spørgsmål gennem joins. Et materialiseret view kan rumme det joinede og\nsummerede resultat, som rapporteringen vil have, mens kildetabellerne beholder\nderes ene kopi af hver oplysning, og hver skrivning stadig går ét sted hen.\n\n## Sådan ser det ud i praksis\n\nTag en webshops ordretabeller: `orders` med én række pr. ordre og den dato, den\nblev afgivet, og `order_lines` med varenummer, antal og stykpris for hver linje.\nEt salgsdashboard skal vise solgte enheder og omsætning pr. produkt pr. dag.\nForespørgslen er kort, men over flere års ordrer læser den hver eneste linje:\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 udelader dagens salg, hvis tal stadig ændrer sig, så dashboardet\nkun viser hele dage; eksemplet i PostgreSQL's egen dokumentation behandler en\ndag med ufærdigt salg på samme måde. Kommandoen kører forespørgslen én gang og\ngemmer resultatet. Derefter kommer et indeks:\n\n```sql\nCREATE UNIQUE INDEX daily_sales_sku_day ON daily_sales (sku, day);\n```\n\nIndekset har to opgaver. Det lader dashboardet finde ét produkts dage uden at\nlæse hele viewet, og det er det, der senere gør en samtidig opdatering mulig.\nForespørgslen grupperer på dag og varenummer, så hvert par optræder én gang, og\nderfor kan indekset være unikt. Fra nu af læser dashboardet viewet som en tabel:\n\n```sql\nSELECT day, units, revenue\nFROM   daily_sales\nWHERE  sku = 'TEA-250'\nORDER  BY day;\n```\n\nHver nat, kort efter midnat, bringer et planlagt job det ajour:\n\n```sql\nREFRESH MATERIALIZED VIEW CONCURRENTLY daily_sales;\n```\n\nUden `CONCURRENTLY` bruger en opdatering, der rører mange rækker, typisk færre\nressourcer og bliver hurtigere færdig, men den kan blokere dashboardets\nlæsninger, indtil den er færdig. Med `CONCURRENTLY` fortsætter læsningerne under\nopdateringen, og dokumentationen bemærker, at det endda kan være det hurtigste\nvalg, når kun få rækker ændres, som her, hvor der kommer én ny dag til hver nat.\nValget har to betingelser. Viewet skal allerede indeholde data, og det skal have\nmindst ét unikt indeks bygget af rene kolonnenavne, som dækker alle rækker,\naltså intet udtryksindeks og ingen `WHERE`-betingelse. Indekset ovenfor opfylder\nden anden; at viewet blev oprettet med sine data, opfyldte den første.\n\nAndre databaser trækker grænsen andre steder. I BigQuery vedligeholdes\nmaterialiserede views i baggrunden: ændringer i basistabellerne lægges trinvist\ntil, uden at nogen beder om det, en forespørgsel mod viewet fletter de seneste\nændringer ind, så resultatet forbliver aktuelt, og smart tuning kan sende en\nforespørgsel, der er skrevet mod basistabellerne, videre til viewet i stedet.\nDet gælder inkrementelle views, som kun accepterer et begrænset udvalg af SQL.\nEt view defineret med `allow_non_incremental_definition = true` accepterer de\nfleste forespørgsler, men hver opdatering kører hele forespørgslen, og\nresultaterne er ikke altid aktuelle.\n\nSQL Server når et lignende resultat gennem indekserede views. Opretter man et\nunikt clustered indeks på et view, som skal være oprettet `WITH SCHEMABINDING`\nog have en deterministisk definition, gemmes resultatet på samme måde som en\ntabel med et clustered indeks, og forespørgselsoptimeringen kan bruge det, også\ntil en forespørgsel, der ikke nævner viewet. SQL Server opdaterer det\nindekserede view sammen med hver insert, update og delete på de tabeller, det\nafhænger af, så der er ingen opdatering at planlægge; omkostningen flytter over\npå skrivningerne, og Microsofts dokumentation advarer om, at deres ydeevne kan\nfalde betydeligt.\n\nDen samme afvejning viser sig i produktionsarbejde. I en tidligere rolle udviklede\ngrundlæggeren [ETL/ELT-pipelines i PL/pgSQL](/da/portfolio/engineered-600-pl-pgsql-etl-elt-pipelines/), som\nbrugte partitionerede tabeller og materialiserede views til at optimere\nlæseydeevnen for store datasæt, sammen med primærnøgler og fremmednøgler for den\nreferentielle integritet og unikke og sammensatte indeks til JOIN-operationerne.\n\n## Hvor det går galt\n\n**Forældede tal, der ser aktuelle ud.** Et opdateringsjob, der holdt op med at\nkøre for en uge siden, efterlader et view, der besvarer hver forespørgsel,\nhurtigt og forkert, og intet i resultatet fortæller, hvor gammelt det er. Lad\njobbet registrere tidspunktet for hver vellykket opdatering et sted, hvor\ndashboardet kan vise det, og send en alarm, når tidspunktet er ældre, end\nlæserne har accepteret.\n\n**En opdatering, der blokerer læserne.** En almindelig\n`REFRESH MATERIALIZED VIEW` over et stort view kan blokere alle sessioner, der\nprøver at læse det, indtil opdateringen er færdig. Tilføj et unikt indeks og\nbrug `CONCURRENTLY`, eller læg de almindelige opdateringer i timer, hvor ingen\nlæser viewet. Når de fleste rækker ændres ved hver kørsel, kan den almindelige\nopdatering stadig være den billigste.\n\n**`CONCURRENTLY` bliver afvist.** Valget kræver et unikt indeks på rene\nkolonner, som dækker alle rækker. Et unikt indeks på `lower(email)`, eller et,\nder er begrænset af en `WHERE`-betingelse, tæller ikke. Det kræver også et view,\nder allerede indeholder data, så det fejler på et view oprettet `WITH NO DATA`,\nog de to valg kan ikke kombineres. Tilføj et indeks, der opfylder kravene, og\nfyld viewet én gang med en almindelig opdatering.\n\n**Et view, der ikke kan scannes.** `WITH NO DATA` opretter viewet uden at køre\nforespørgslen og markerer det som ikke-scanbart, og enhver forespørgsel mod det\nfejler frem til den første opdatering. Det kan være det rigtige valg i en\nmigrering, der ikke skal vente på en lang forespørgsel, men så skal den første\nopdatering planlægges, ikke glemmes.\n\n**En ændret definition, der aldrig nåede frem.**\n`CREATE MATERIALIZED VIEW IF NOT EXISTS` i en migrering gør intet ud over at\nudsende en notice, når et view med det navn allerede findes, og dokumentationen\ngaranterer ikke, at det eksisterende view ligner den nye definition. En\nmigrering, der ændrer forespørgslen på den måde, lader den gamle blive stående.\nFjern viewet med `DROP MATERIALIZED VIEW`, og opret det igen i samme migrering.\n\n**Opdateringsjob, der overlapper.** Der kan kun køre én opdatering ad gangen mod\net givet materialiseret view, også med `CONCURRENTLY`, så en tidsplan, der er\ntættere end selve opdateringen, efterlader kun viewet længere bagud. Mål, hvor\nlang tid en opdatering tager, og læg tidsplanen ud fra det.\n\n**At stole på rækkernes rækkefølge.** Har den definerende forespørgsel en\n`ORDER BY`, kommer det første indhold i den rækkefølge, men en opdatering lover\nikke at bevare den. Sæt `ORDER BY` i de forespørgsler, der læser viewet.\n\n**Funktioner, der mister deres tabeller.** Mens den definerende forespørgsel\nkører, ved oprettelsen eller ved en opdatering, sætter PostgreSQL midlertidigt\n`search_path` til `pg_catalog, pg_temp` og begrænser, hvad forespørgslen må: en\nfunktion, der opretter midlertidige tabeller, fejler. En funktion, der finder\nsine tabeller ved et ukvalificeret navn, kan bestå hver test i hånden og først\ngå i stykker inde i opdateringen. Kvalificér tabelnavnene med skemaet i alle\nfunktioner, viewet kalder.\n\n**Den forkerte rolle kører jobbet.** En opdatering kræver privilegiet `MAINTAIN`\npå det materialiserede view. Et job, der kører som en rapporteringsrolle, der må\nlæse viewet, men ikke vedligeholde det, fejler hver nat. Giv den rolle, der\nkører opdateringen, det privilegium.\n\n**En gemt kopi, hvor et indeks ville være nok.** Er en forespørgsel langsom,\nfordi der mangler et indeks, skjuler et materialiseret view problemet og lægger\nforældede data oven i. Læs forespørgselsplanen først. Når en forespørgsel blot\nskal have et navn, er et almindeligt view nok, og det er altid aktuelt; gem\nmaterialiserede views til resultater, der er dyre at beregne og ufarlige at læse\nlidt gamle.\n\n## Læs mere\n\n- [Materialized Views](https://www.postgresql.org/docs/current/rules-materializedviews.html)\n  — PostgreSQL's kapitel om, hvordan materialiserede views forholder sig til\n  views og tabeller, med et salgsoverblik, der opdateres hver nat, og et\n  eksempel med en foreign data wrapper.\n- [CREATE MATERIALIZED VIEW](https://www.postgresql.org/docs/current/sql-creatematerializedview.html)\n  — kommandoreferencen, herunder `WITH NO DATA`, `IF NOT EXISTS` og den\n  begrænsede `search_path`, mens forespørgslen kører.\n- [REFRESH MATERIALIZED VIEW](https://www.postgresql.org/docs/current/sql-refreshmaterializedview.html)\n  — opdateringskommandoen, betingelserne for `CONCURRENTLY` og privilegiet\n  `MAINTAIN`, som den kræver.\n- [PostgreSQL 9.3 release notes](https://www.postgresql.org/docs/9.3/release-9-3.html)\n  — udgivelsen fra september 2013, der tilføjede materialiserede views.\n- [Introduction to materialized views](https://cloud.google.com/bigquery/docs/materialized-views-intro)\n  — BigQuerys inkrementelle og ikke-inkrementelle materialiserede views,\n  automatisk opdatering og smart tuning.\n- [Create indexed views](https://learn.microsoft.com/en-us/sql/relational-databases/views/create-indexed-views)\n  — SQL Servers indekserede views, kravene til dem og deres pris for\n  skrivningerne.\n\n\u003chttps://engineer.company/da/glossary/materialized-view/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hvad et materialiseret view er: et gemt forespørgselsresultat i PostgreSQL, REFRESH og CONCURRENTLY, BigQuery og SQL Server, og hvor det går galt.","formats":{"gemtext":"https://engineer.company/da/glossary/materialized-view/index.gmi","gopher":"https://engineer.company/da/glossary/materialized-view/gophermap","html":"https://engineer.company/da/glossary/materialized-view/","json":"https://engineer.company/da/glossary/materialized-view/index.json","markdown":"https://engineer.company/da/glossary/materialized-view/index.md","pdf":"https://engineer.company/da/glossary/materialized-view/index.pdf"},"kind":"page","language":"da","title":"Hvad er et materialiseret view?","url":"https://engineer.company/da/glossary/materialized-view/","version":1}