{"canonical_url":"https://engineer.company/da/notes/optimise-before-you-shard/","content_markdown":"# Optimér databasen, før du sharder den\n\n2026-10-14\n\nNår en database bliver langsom under belastning, er det første forslag som\nregel flere maskiner. Nogle gange er det rigtigt. Oftere er den langsomme del\nen håndfuld sætninger, som ingen har læst endnu, og at sprede data over flere\nservere spreder de sætninger over mere hardware uden at gøre én eneste af dem\nbilligere. Et problem, der ser uløseligt ud, ligger ofte kun én forespørgselsplan fra en\npæn løsning, og horisontal skalering vælges nogle gange netop, så ingen behøver at\nlæse\nden database, du allerede har *(læs den, før du køber mere af den)*.\n\nDet her er rækkefølgen, vi arbejder i, før vi deler noget: kig, stram op, tag\nlæsningerne væk fra den primære, partitionér tabellerne omkring det varme punkt,\nog shard først, når én maskine er fuld af godt arbejde. Flash-salget, hvor alle\nkøbere skriver til én række, er gennemgået i\n[At sælge den sidste billet præcis én gang](/da/notes/selling-limited-stock-without-overselling/).\nDenne note beskriver metoden omkring det, og dens sidste afsnit tager det modsatte\nforslag op: sælg fra hver server, og undskyld for de enheder, der blev solgt to\ngange.\n\n## Kig først\n\nPostgreSQL registrerer allerede det meste af det, der er at vide. Stil den fire\nspørgsmål, før du ændrer noget.\n\n**Hvilke sætninger koster mest i alt?** `pg_stat_statements`, en udvidelse, der\nindlæses gennem `shared_preload_libraries`, gemmer hver normaliseret sætning med\nantal kald og tid. Sortér efter total, ikke efter gennemsnit: en\nSQL-forespørgsel på 2 ms, der kører en million gange i timen, koster mere end en\nrapport på to sekunder, der kører to gange.\n\n```sql\nSELECT calls,\n       round(total_exec_time) AS total_ms,\n       round(mean_exec_time::numeric, 1)\n         AS mean_ms,\n       left(query, 60) AS query\n  FROM pg_stat_statements\n ORDER BY total_exec_time DESC\n LIMIT 10;\n```\n\n**Hvad gør den øverste egentlig?** `EXPLAIN (ANALYZE, BUFFERS)` kører sætningen\nog viser den plan, den valgte, de rækker, hvert trin faktisk returnerede, mod\ndem, den forventede, og hvor mange sider den læste. En scanning af en million\nrækker for at returnere ti, eller et estimat, der rammer ved siden af med en\nfaktor hundrede, er som regel hele historien. `ANALYZE` udfører det, den\nforklarer, så pak en skrivning ind i `BEGIN` og `ROLLBACK`.\n\n**Hvem venter, og på hvem?**\n\n```sql\nSELECT pid, wait_event_type, wait_event,\n       pg_blocking_pids(pid) AS blocked_by,\n       left(query, 60) AS query\n  FROM pg_stat_activity\n WHERE wait_event_type = 'Lock';\n```\n\nRækker her i et travlt minut betyder, at transaktioner venter på hinanden, ikke\npå hardware, og en større maskine fjerner ikke kravet om, at opdateringer af én\nfælles række udføres én ad gangen. Flere applikationsservere kan føje skrivende\nklienter til den kø.\n\n**Arbejder serveren, eller jonglerer den?** Sammenlign antallet af aktive sessioner i\n`pg_stat_activity` med antallet af kerner. Når mange gange flere er aktive, end der er\nkerner, bruger serveren sin tid på at skifte mellem dem, og en forbindelsespulje\nløser det, før nogen hardware gør. Læs derefter `n_dead_tup` i\n`pg_stat_user_tables`: en tabel med flere døde rækker end levende bliver scannet\ngennem sit eget affald, og det er autovacuum, der halter bagefter, ikke en\ndatabase, der er for lille.\n\nSkriv ned, hvad du finder. Det er udgangspunktet, som hvert senere skridt måles\nmod, og det ærlige svar på \"skal vi sharde?\" står ofte allerede i det.\n\n## Stram op i det, der er\n\nNogenlunde i rækkefølge efter udbytte i forhold til indsats.\n\n**Indekser, der passer til spørgsmålene.** Planerne ovenfor udpeger\nscanningerne. Et indeks på de kolonner, en varm forespørgsel filtrerer på, gør\nen scanning til et opslag, og et partielt indeks rummer kun de rækker, en\nforespørgsel kan have brug for — for eksempel enheder, der stadig er til salg — så\ndet skrumper, mens et salg skrider frem, i stedet for at vokse:\n\n```sql\nCREATE INDEX units_unsold\n    ON units (item_id)\n WHERE NOT sold;\n```\n\nHvert indeks betales også ved hver skrivning, så fjern de indekser, hvis `idx_scan` i\n`pg_stat_user_indexes` bliver ved med at stå på nul.\n\n**Typer, der siger, hvad værdien er.** Skemaer skrevet hurtigt, af et menneske\neller en model, griber efter `TEXT`, hvor en `SMALLINT` eller en `BOOLEAN` ville\nvære nok. En `BOOLEAN` er én byte, en `SMALLINT` to, og `'yes'` gemt som tekst\ner fire. PostgreSQL indsætter desuden fyld, så hver kolonne med fast bredde\nbegynder på sin egen justeringsgrænse, og en kolonnerækkefølge valgt tilfældigt\nkoster derfor også bytes. Én lagerenhed, skrevet hurtigt:\n\n```sql\nCREATE TABLE units (\n  sold        text,  -- 'yes' eller 'no'\n  id          bigint,\n  reserved    text,  -- 'yes' eller 'no'\n  reserved_at timestamptz,\n  item_id     bigint,\n  order_id    bigint\n);\n```\n\nOg den samme enhed med typer, der siger, hvad værdierne er, de bredeste først:\n\n```sql\nCREATE TABLE units (\n  id          bigint PRIMARY KEY,\n  reserved_at timestamptz,\n  order_id    bigint,\n  item_id     integer NOT NULL,\n  sold        boolean NOT NULL DEFAULT false,\n  reserved    boolean NOT NULL DEFAULT false\n);\n```\n\nPå PostgreSQL 18 måler den første række 72 bytes og den anden 54, en fjerdedel\nmindre, så mere af tabellen kan ligge i hukommelsen. Typerne afviser også\nværdier som `'maybe'`, som applikationen ellers skulle forsvare sig imod, og en\n`CHECK`-begrænsning gør det samme for værdiområder:\n`quantity smallint CHECK (quantity \u003e 0)`.\n\n**Færre rundture, og arbejdet der, hvor data er.** Hver sætning, applikationen\nsender, koster en rundtur og en parsning. En løkke, der læser hundrede rækker og\nopdaterer dem én ad gangen, er hundrede og én rundture, hvor én mængdebaseret\nsætning ville gøre det, og en side, der henter hver enhed af en vare for at\ntælle de ledige, sender tusindvis af rækker for at beregne ét tal. Reglen, vi\nbruger: det, der skal se data, går til databasen — filtrering, optælling, en\nskrivning, der afhænger af, hvad der er der — og forretningsregler bliver i\napplikationen, fordi databasens CPU er den, det er sværest at få mere af i hele\nsystemet.\n\n**Opdateringer, der bliver på deres side.** En række, der ændres mange gange i\nminuttet, efterlader en ny version af sig selv hver gang. Når en opdatering ikke\nændrer nogen indekseret kolonne, og siden har plads, beholder PostgreSQL den nye\nversion på samme side og rører slet ikke noget indeks: en heap-only tuple, eller\nHOT-opdatering. Hold derfor de kolonner, en hyppig opdatering ændrer, ude af\nindeksene, og efterlad plads på siderne:\n\n```sql\nALTER TABLE units SET (fillfactor = 90);\n```\n\nIndstillingen gælder for sider, der skrives fra da af, så sæt den, før rækkerne\nindlæses. På tabellen ovenfor var 2.000 reservationer, der satte `reserved`,\n`reserved_at` og `order_id`, alle HOT, og af 2.000 opdateringer, der satte\n`sold`, som det partielle indeks læser, var ingen HOT. Et salg sker én gang pr.\nenhed; en reservation kan ske mange gange. `n_tup_hot_upd` mod `n_tup_upd` i\n`pg_stat_user_tables` viser forholdet på et system i drift.\n\n## Én række siger, hvem der kom først\n\nEn enhed går til den første køber, hvis sætning når den, og reservationen\nudløber på databasens ur. Den hviler på to kolonner: `reserved`, en boolean, og\n`reserved_at`, det øjeblik, den blev sat.\n\n```sql\nUPDATE units\n   SET reserved = true,\n       reserved_at = now(),\n       order_id = :order\n WHERE id = :unit\n   AND NOT sold\n   AND (NOT reserved\n        OR reserved_at\n           \u003c now() - interval '10 minutes')\nRETURNING id;\n```\n\nÉn række tilbage: denne køber har den. Ingen: en anden kom først, eller den er\nsolgt. To reservationer på samme enhed står i kø ved dens rækkelås, og under READ\nCOMMITTED, PostgreSQL's standard, tjekker den anden `WHERE`-betingelsen igen mod\nden række, den første committede, så præcis én af dem får en række tilbage. En\nreservation, der er ældre end ti minutter, tæller som ledig, så intet behøver at\nrydde den op, for at svaret er rigtigt.\n\nDet gør boolean'en alene til et ufuldstændigt svar. `reserved` forbliver sand,\nefter en reservation er udløbet, og kun de to kolonner sammen siger, om en enhed\ner optaget, så hver forespørgsel, der spørger, skal spørge til begge. En periodisk\noprydning, der nulstiller udløbne reservationer, holder tabellen ærlig for den,\nder læser `reserved` alene, men korrektheden venter aldrig på den. En\nbegrænsning holder parret konsistent:\n\n```sql\nALTER TABLE units\n  ADD CONSTRAINT reserved_has_time\n  CHECK (NOT reserved\n         OR reserved_at IS NOT NULL);\n```\n\nBilletnoten gemmer fristen, `held_until`, i stedet for starten; det er det\nsamme design. Når køberen vælger enheden — et sæde, et nummereret tryk —\nnavngiver sætningen den, som her. Når en hvilken som helst enhed er god nok,\nvælger varianten med `SKIP LOCKED` i den note en enhed, som ingen andre har\nreserveret.\n\n## Læsninger væk fra den primære\n\nDet meste af en butiks trafik er læsning: produktsiden, \"3 tilbage\", kurven,\nordrehistorikken. Intet af det har brug for den primære, den ene maskine, der\nskal holdes fri til skrivninger. En streaming-replika tager de læsninger, og at\ntilføje én er et spørgsmål om konfiguration, mens en shard er et projekt.\n\nTo forbehold følger med. En replika halter en smule bagefter, så en køber, der\nlige har reserveret en enhed og så læser sin kurv fra den, ser måske ikke\nreservationen: læs det, en bruger lige har skrevet, fra den primære, eller send\nden bruger til den primære i nogle sekunder efter hver skrivning. Og en lang\nrapport på en replika kan blive annulleret, når den holder de ændringer\ntilbage, replikaen afspiller. PostgreSQL-dokumentationen kalder det\nforespørgselskonflikter og nævner de indstillinger, der afvejer replikaens\nforsinkelse mod dem.\n\nDen billigste læsning er den, der aldrig når en database. Når hver enhed af en\nvare er reserveret, kan ingen købe den, før en reservation udløber eller\nfrigives, og databasen kan sige præcis, hvornår det er:\n\n```sql\nSELECT count(*) FILTER (\n         WHERE NOT reserved\n            OR reserved_at\n               \u003c now() - interval '10 minutes')\n         AS free,\n       min(reserved_at) + interval '10 minutes'\n         AS until\n  FROM units\n WHERE item_id = :item\n   AND NOT sold;\n```\n\nNår `free` er nul, er `until` det øjeblik, den tidligste reservation udløber:\ncache \"fuldt reserveret\" med det som udløbstid, aldrig længere, og hver\nbesøgende indtil da bliver afvist af cachen i stedet for af databasen. Når\n`free` er nul, og `until` er tom, er hver enhed solgt, og svaret er endeligt.\nEn reservation, der frigives tidligt — et afvist kort, en forladt kurv — sletter\ncache-posten, så enheden er til salg igen med det samme.\n\nCachen siger kun nej. Et ja kommer altid fra den betingede `UPDATE` ovenfor, så\nen forældet cache kan koste et salg i nogle sekunder og kan aldrig sælge en\nenhed to gange. Det er billetnotens cachede \"udsolgt\", med en frist.\n\n## Partitionér tabellerne omkring den varme række\n\nPartitionering deler én tabel i flere efter en nøgle — en måned, en lejer — bag\nét navn. Det er værd at sige ligeud, hvad den ikke gør: den gør ikke én række, som flere transaktioner kæmper om, hurtigere. Den række ligger stadig i én partition, på én maskine,\nbag én lås.\n\nDet, den gør, er at holde tabellerne omkring det varme punkt små. Ordrer,\nreservationshistorik og hændelser vokser uden ophør, og de fleste forespørgsler\nvil have den nyeste del:\n\n```sql\nCREATE TABLE orders (\n  id          bigint NOT NULL,\n  created_at  timestamptz NOT NULL\n              DEFAULT now(),\n  item_id     integer NOT NULL,\n  quantity    smallint NOT NULL\n              CHECK (quantity \u003e 0),\n  paid        boolean NOT NULL DEFAULT false,\n  PRIMARY KEY (id, created_at)\n) PARTITION BY RANGE (created_at);\n\nCREATE TABLE orders_2026_10\n  PARTITION OF orders\n  FOR VALUES FROM ('2026-10-01')\n              TO ('2026-11-01');\n```\n\nEn forespørgsel, der nævner et datointerval, læser kun partitionerne inden for\ndet, og denne måneds indekser forbliver små nok til at ligge i hukommelsen.\nOprydning holder op med at være en `DELETE` af millioner af rækker, med den\noppustning og vacuum, der følger, og bliver én sætning:\n\n```sql\nALTER TABLE orders\n  DETACH PARTITION orders_2025_10;\n```\n\nPrimærnøglen skal indeholde partitionsnøglen, og derfor er den\n`(id, created_at)`. En forespørgsel, der ikke nævner nøglen, læser hver\npartition, så partitionér efter det, forespørgslerne allerede filtrerer på.\n\n## Når sharding er rimeligt\n\nDer er én grænse, sharding ikke kan flytte: hver vare har én ejer. En enhed kan\nikke reserveres på to servere på samme tid, så sharding flytter hele varer,\naldrig halvdelen af én. Når en enkelt vare vokser fra sin maskine, deler\nbilletnotens spande dens lager i mindre stykker, og hvert stykke har igen\npræcis én ejer.\n\nInden for det kalder vi sharding rimeligt, når én af disse ting er sand, og\nikke før:\n\n- **Én maskine er fuld af godt arbejde.** Sætningerne er allerede slanke — én\n  betinget skrivning hver, intet eksternt inde i en transaktion, opdateringer,\n  der bliver på deres side — og den primæres CPU eller write-ahead-log er stadig\n  mættet, på den største maskine, det er værd at købe, på tværs af mange varer\n  og ikke kun én. Én varm vare er et spandeproblem, ikke et shardproblem.\n- **Datamængden er vokset fra vedligeholdelsen.** En backup kan ikke gendannes\n  inden for den tid, forretningen er lovet, et indeks kan ikke bygges eller en\n  tabel vacuumes i de stille timer, eller arbejdssættet passer ikke længere i\n  hukommelsen.\n- **Isolation er kravet.** En lejer, hvis kontrakt eller tilsynsmyndighed siger,\n  at deres data skal ligge for sig selv, eller hvis salg ikke må dele disk med nogen\n  andens.\n\nPrisen lander på alt andet. Migreringer, backup, gendannelser og rapporter skal\ntage højde for separate shards; en joinoperation på tværs af shards kan flyttes\ntil applikationskoden; og en forespørgsel, der ikke kender sin shardnøgle, kan\nvære nødt til at spørge dem alle. Det er regningen, afsnittene ovenfor er der\nfor at undgå, og når den først er betalt, er den svær at få tilbage.\n\n## Når en undskyldning er billigere end en lås\n\nDer findes et seriøst argument for at gå den anden vej. Lad hver server sælge af\ndet lager, den kan se, acceptér, at en enhed nu og da går til to købere, og lad\nkundeservice refundere den ene af dem med en undskyldning. Forretningslogikken\nbliver konsistent med tiden (eventual consistency), bygget til de 99,9 % af\nforespørgslerne, der aldrig støder sammen, og en asynkron løkke finder\nsammenstødene bagefter og retter op på dem. Til gengæld behøver butikken aldrig\nat sige \"prøv igen\". Helland og Campbell giver argumentet dets stærkeste form i\n_Building on Quicksand_: et system, der kvitterer for arbejde, før dets backup\nhar det, gør hvert løfte til en sandsynlighed, og virksomheder har altid gjort\nde løfter, de ikke kunne holde, op med en undskyldning.\n\nVi er enige i det meste af det. Vi er uenige om, hvor det skal bruges.\n\n**Det meste af en butik bør være konsistent med tiden.** Kataloget,\nsøgeindekset, mærket \"3 tilbage\", kurven, anbefalingerne, mailene, lagerfeedet\nog rapporterne kan alle køre sekunder bagud, og at lade dem vente på den primære\nkoster fart og giver intet igen. Dynamo blev bygget til netop det: Amazons\nindkøbskurv glemmer eller afviser aldrig et \"læg i kurven\", heller ikke mens\nmaskiner fejler, og prisen er, at en fletning kan bringe en vare tilbage, som\nkøberen havde fjernet. Efter reservationen er billetnotens checkout allerede\nasynkron: en saga af lokale trin, beskeder, der leveres mindst én gang, og\nforbrugere, der er idempotente, med ordren som nøgle. En afstemningsløkke hører\nhjemme i ethvert design, der taler med en betalingsudbyder, for webhooks går\ntabt.\n\n**Reservationen er det ene sted, hvor det ikke holder.** \"Sjældent\" forudsætter,\nat sammenstød er sjældne, og i et flash-salg er sammenstødene salget. En server,\nder sælger ud fra sit eget billede, bliver ved med at sælge, indtil den hører,\nhvad de andre har solgt, så oversalget er omtrent forsøgsraten gange\nreplikeringsforsinkelsen. I en simpel simulering deler to regioner 2.000 forsøg\ni sekundet, hver sælger ud fra sin egen optælling og hører om den andens salg\n200 millisekunder senere. Over fem kørsler af et salg på 10.000 enheder solgte\nhver kørsel mellem 191 og 205 enheder, der ikke fandtes. Regnestykket forudsiger\n200: forsøgsraten gange forsinkelsen gange den andel af salget, der sker i den\nanden region. Med én ejer pr. vare solgte den samme model præcis det, der var på\nlager. Det sker, hver gang lageret bliver solgt ud, uanset om noget fejlede, og\ndet sker på højdepunktet, når flest købere ser med.\n\n**Oppetiden er mindre, end den lyder.** Gilbert og Lynch beviste den\nbyttehandel, som konsistens med tiden indgår: mens netværket er delt, kan et\nsystem svare, eller det kan være konsistent, ikke begge dele. Abadis PACELC\ntilføjer den anden halvdel. Når intet er delt, står valget mellem latens og\nkonsistens, og én ejer pr. vare med slanke sætninger er allerede hurtig. Ingen\naf de to designs når 100 %: betalingsudbyderen, DNS og netværkene imellem har\nderes egne nedbrud. Det, det strenge design giver afkald på, er begrænset. Når\nejeren af én vares lager ikke kan nås, holder den vare op med at sælge i de\nsekunder, en failover tager, og billetnotens afsnit om at sætte varen på pause\nbegrænser pausen til varerne på den maskine, der fejlede. Resten af butikken\nsælger videre.\n\n**En undskyldning er ikke en refusion.** Refusionen er den billige del. Køberen\nfik et ja og har måske allerede bestilt toget, taget fri og fortalt det til\nvennerne. At høre \"udsolgt\" et sekund for tidligt er en skuffelse. At høre, at\nen bekræftet ordre er trukket tilbage, er et brudt løfte. Kundeservice er\nbemandet til en almindelig dag, og oversalg kommer samlet, i årets travleste\nminut. Før du planlægger at trække bekræftede ordrer tilbage, så spørg en\njurist, hvad en bekræftelse forpligter butikken til.\n\n**Behold den asynkrone del, og flyt den før ja'et.** Det, forslaget har ret i,\ner, at køberen ikke skal vente på en lås. Tag imod hvert klik i en holdbar,\nreplikeret log, én partition pr. vare, og fortæl køberen, at svaret er på vej.\nAt tage imod et klik afhænger så kun af loggen, og en log, der er replikeret\nover tre maskiner, bliver ved med at tage imod skrivninger, når én af dem\nfejler. Én ejer pr. vare læser loggen i rækkefølge og beslutter i hukommelsens\ntempo, og svaret går tilbage som en besked inden for sekunder. Når den ejer får\nen failover, venter forespørgslerne i loggen i stedet for at blive afvist eller\nsolgt to gange. Ja'et er en reservation, og betalingen følger efter, som i\nbilletnotens checkout, så ingen betaler for en enhed, de ikke fik. Afstemningen\nsker stadig, men før løftet i stedet for efter det.\n\n**Del lageret, ikke optællingen.** Når forretningen har brug for, at regioner\nsælger uden at spørge hinanden, så giv hver region en kvote af lageret, og lad\nden sælge af sin egen kvote uden at spørge nogen. En region, hvis kvote slipper\nop, beder om mere, og mod slutningen af salget falder kvoterne tilbage til én\nejer. Bailis og kolleger kortlægger, hvilke regler servere kan overholde uden\nat tale sammen, og et lager, der ikke må gå under nul, er ikke en af dem. Kvoter\nfjerner ikke den samtale; de flytter den væk fra det enkelte salg, til det\nsjældne øjeblik, hvor en kvote fyldes op. Det er det design, der er konsistent\nmed tiden og alligevel holder invarianten. Dets eneste pris er halen, hvor en\nkøber bliver afvist i én region, mens en anden region stadig har lager.\n\n**Når oversalg er den rigtige politik.** Nogle varer kan laves igen: et print on\ndemand, en T-shirt, som leverandøren stadig har, en licensnøgle. At sælge ud over\nlagertallet er så en restordre med en ærlig dato, og konsistens med tiden er det\nrigtige design. Flyselskaber overbooker med vilje. De kender deres\nudeblivelsesrater, prissætter risikoen og kompenserer efter en regel, der er\nskrevet på forhånd. Det er testen. Et oversalg er acceptabelt, når forretningen\nvalgte dets størrelse og dets afhjælpning før salget. Det er en fejl, når det\nrammer den, der tilfældigvis klikkede sidst.\n\n**Hvis du vælger undskyldninger, så byg dem som betalinger.** Løkken, forslaget\nbeskriver, er en refusionspipeline, og den har brug for det samme som alt andet,\nder flytter penge:\n\n- **Et id på hvert salg,** så et nyt forsøg er det samme salg, og en journal\n  over salg, som der kun tilføjes til. Lagertallet udledes af journalen og\n  redigeres aldrig.\n- **En regel for, hvem der beholder enheden,** som du kunne forklare den køber,\n  der tabte. Ordn efter loggen, ikke efter forskellige serveres ure, hvor få\n  millisekunders forskydning ville afgøre, hvem der får refusionen.\n- **Kompensationer, der er idempotente og logget:** annullér, frigiv eller\n  refundér, og fortæl køberen det. De er sagaens fortryd-trin, kørt af en\n  maskine.\n- **En frist.** Løkken skal finde hvert oversalg, før noget bliver sendt, og før\n  køberen finder det.\n- **Et budget, målt.** Oversalg pr. salg, mod det tal, forretningen skrev under\n  på, ved siden af invarianten på samme dashboard, med en alarm, når budgettet\n  er brugt.\n\nVores svar er at være konsistent med tiden overalt omkring reservationen, streng\nved reservationen og asynkron i den måde, svaret når køberen på. Design efter det\nalmindelige forløb, men i et flash-salg er sammenstødet det almindelige forløb. Hvis\nforretningen vil have nogle få oversalg til gengæld for noget, så gør det til et\ntal, forretningen valgte, med en afhjælpning skrevet før salget, og mål det.\n\n## Hvad vi ville sige til den næste\n\n- **Læs, før du køber.** `pg_stat_statements` og én `EXPLAIN` besvarer flere\n  kapacitetsspørgsmål end en ny server.\n- **Lad typerne sige, hvad data er.** En boolean gemt som boolean er mindre, og\n  den afviser vrøvl.\n- **Send databasen det, der skal se data, og intet andet.** Filtrering og\n  optælling hører hjemme dér. Forretningsregler gør ikke.\n- **Cachen siger nej; kun databasen siger ja.** Så koster en forældet cache\n  sekunder, aldrig en enhed.\n- **Partitionering er oprydning.** Den holder tabellerne omkring en varm række\n  små og gør intet for rækken.\n- **Shard, når én maskine er fuld af godt arbejde,** ikke når den er fuld af\n  venten.\n- **Afstem før ja'et, ikke efter.** Alt omkring reservationen kan være konsistent\n  med tiden. Selve reservationen, lavet på den måde, oversælger med forsøgsraten\n  gange forsinkelsen, ved hvert salg.\n\n## Kilder\n\n- [PostgreSQL: pg_stat_statements](https://www.postgresql.org/docs/current/pgstatstatements.html)\n- [PostgreSQL: brug af EXPLAIN](https://www.postgresql.org/docs/current/using-explain.html)\n- [PostgreSQL: det kumulative statistiksystem](https://www.postgresql.org/docs/current/monitoring-stats.html)\n- [PostgreSQL: numeriske typer](https://www.postgresql.org/docs/current/datatype-numeric.html)\n- [PostgreSQL: tegntyper](https://www.postgresql.org/docs/current/datatype-character.html)\n- [PostgreSQL: boolean-typen](https://www.postgresql.org/docs/current/datatype-boolean.html)\n- [PostgreSQL: partielle indekser](https://www.postgresql.org/docs/current/indexes-partial.html)\n- [PostgreSQL: heap-only tuples (HOT)](https://www.postgresql.org/docs/current/storage-hot.html)\n- [PostgreSQL: tabelpartitionering](https://www.postgresql.org/docs/current/ddl-partitioning.html)\n- [PostgreSQL: hot standby og forespørgselskonflikter](https://www.postgresql.org/docs/current/hot-standby.html)\n- [Pat Helland og Dave Campbell, Building on Quicksand](https://arxiv.org/abs/0909.1788)\n- [Seth Gilbert og Nancy Lynch, Brewer's Conjecture and the Feasibility of Consistent, Available, Partition-Tolerant Web Services](https://groups.csail.mit.edu/tds/papers/Gilbert/Brewer2.pdf)\n- [Daniel Abadi, Consistency Tradeoffs in Modern Distributed Database System Design](https://www.cs.umd.edu/~abadi/papers/abadi-pacelc.pdf)\n- [DeCandia et al., Dynamo: Amazon's Highly Available Key-value Store](https://www.allthingsdistributed.com/files/amazon-dynamo-sosp2007.pdf)\n- [Hector Garcia-Molina og Kenneth Salem, Sagas](https://www.cs.cornell.edu/andru/cs711/2002fa/reading/sagas.pdf)\n- [Bailis et al., Coordination Avoidance in Database Systems](https://www.vldb.org/pvldb/vol8/p185-bailis.pdf)\n\n\u003chttps://engineer.company/da/notes/optimise-before-you-shard/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"De fleste databaser, der ser ud til at skulle shardes, skal læses først. Rækkefølgen: mål, stram op, flyt læsninger, partitionér og shard til sidst.","formats":{"gemtext":"https://software.engineer.company/da/notes/optimise-before-you-shard/index.gmi","gopher":"https://software.engineer.company/da/notes/optimise-before-you-shard/gophermap","html":"https://software.engineer.company/da/notes/optimise-before-you-shard/","json":"https://software.engineer.company/da/notes/optimise-before-you-shard/index.json","markdown":"https://software.engineer.company/da/notes/optimise-before-you-shard/index.md","pdf":"https://software.engineer.company/da/notes/optimise-before-you-shard/index.pdf"},"kind":"page","language":"da","title":"Optimér databasen, før du sharder den","url":"https://software.engineer.company/da/notes/optimise-before-you-shard/","version":1}