{"canonical_url":"https://engineer.company/nb/notes/optimise-before-you-shard/","content_markdown":"# Optimaliser databasen før du sharder den\n\n2026-10-14\n\nNår en database blir treg under last, er det første forslaget som regel flere\nmaskiner. Noen ganger er det riktig. Oftere er den trege delen en håndfull\nsetninger ingen har lest ennå, og å spre dataene over flere servere sprer de\nsetningene over mer maskinvare uten å gjøre én eneste av dem billigere. Et\nproblem som ser uløselig ut, er ofte én spørringsplan unna et elegant svar, og\nhorisontal skalering velges iblant nettopp for at ingen skal måtte lese\ndatabasen du allerede har *(les den før du kjøper mer av den)*.\n\nDette er rekkefølgen vi arbeider i før vi deler opp noe: se, stram inn, ta\nlesingene bort fra primærnoden, partisjoner tabellene rundt det hete punktet, og\nshard først når én maskin er full av godt arbeid. Lynsalget, der hver kjøper\nskriver til én rad, er gjennomgått i\n[Å selge den siste billetten nøyaktig én gang](/nb/notes/selling-limited-stock-without-overselling/).\nDette notatet er metoden rundt det, og den siste delen tar for seg det motsatte\nforslaget: selg fra hver server, og be om unnskyldning for enhetene som ble\nsolgt to ganger.\n\n## Se først\n\nPostgreSQL registrerer allerede det meste det er å vite. Før du endrer noe, still\nden fire spørsmål.\n\n**Hvilke setninger koster mest totalt?** `pg_stat_statements`, en utvidelse som\nlastes via `shared_preload_libraries`, tar vare på hver normaliserte setning med\nantall kall og tidsbruk. Sorter etter total, ikke etter gjennomsnitt: en spørring\npå 2 ms som kjøres en million ganger i timen, koster mer enn en rapport på to\nsekunder som kjøres to ganger.\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**Hva gjør den øverste egentlig?** `EXPLAIN (ANALYZE, BUFFERS)` kjører setningen\nog viser planen den valgte, radene hvert steg faktisk returnerte mot radene det\nforventet, og hvor mange sider den leste. En skanning av en million rader for å\nreturnere ti, eller et estimat som bommer med en faktor hundre, er som regel hele\nhistorien. `ANALYZE` utfører det den forklarer, så pakk en skriving inn i `BEGIN`\nog `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\nRader her i et travelt minutt betyr at transaksjoner venter på hverandre, ikke\npå maskinvare, og en større maskin fjerner ikke kravet om at oppdateringer av én\nfelles rad utføres én om gangen. Flere applikasjonsservere kan føye skrivende\nklienter til den køen.\n\n**Arbeider serveren, eller sjonglerer den?** Tell de aktive øktene i\n`pg_stat_activity` mot kjernene. Når mange ganger flere er aktive enn det finnes\nkjerner, bruker serveren tiden sin på å bytte mellom dem, og en tilkoblingspool\nløser det før noen maskinvare gjør det. Les deretter `n_dead_tup` i\n`pg_stat_user_tables`: en tabell med flere døde rader enn levende blir skannet\ngjennom sitt eget søppel, og det er autovacuum som henger etter, ikke en database\nsom er for liten.\n\nSkriv ned det du finner. Det er utgangspunktet hvert senere steg måles mot, og\ndet ærlige svaret på «må vi sharde?» ligger ofte allerede der.\n\n## Stram inn det som er der\n\nOmtrent i rekkefølge etter gevinst for innsatsen.\n\n**Indekser som passer til spørsmålene.** Planene ovenfor navngir skanningene. En\nindeks på kolonnene en het spørring filtrerer på, gjør en skanning om til et\noppslag, og en partiell indeks inneholder bare radene en spørring kan være ute\netter — enheter som fortsatt er til salgs, for eksempel — så den krymper etter\nhvert som et salg skrider frem, i stedet for å vokse:\n\n```sql\nCREATE INDEX units_unsold\n    ON units (item_id)\n WHERE NOT sold;\n```\n\nHver indeks betales også ved hver skriving, så fjern dem der `idx_scan` i\n`pg_stat_user_indexes` blir stående på null.\n\n**Typer som sier hva verdien er.** Skjemaer skrevet i en fart, av et menneske\neller en modell, griper etter `TEXT` der en `SMALLINT` eller en `BOOLEAN` ville\nholdt. En `BOOLEAN` er én byte, en `SMALLINT` to, og `'yes'` lagret som tekst er\nfire. PostgreSQL fyller også ut slik at hver kolonne med fast bredde havner på\nsin egen justeringsgrense, så en kolonnerekkefølge som er valgt tilfeldig, koster\nogså byte. Én lagerenhet, skrevet i en fart:\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 enheten med typer som sier hva verdiene 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 raden 72 byte og den andre 54, en fjerdedel\nmindre, så mer av tabellen får plass i minnet. Typene avviser også verdier som\n`'maybe'`, som applikasjonen ellers måtte forsvare seg mot, og en `CHECK`-skranke\ngjør det samme for verdiområder: `quantity smallint CHECK (quantity \u003e 0)`.\n\n**Færre rundturer, og arbeidet der dataene er.** Hver setning applikasjonen\nsender, koster en rundtur og en parsing. En løkke som leser hundre rader og\noppdaterer dem én etter én, er hundre og én rundturer der én mengdebasert\nsetning ville holdt, og en side som henter hver enhet av en vare for å telle de\nledige, sender tusenvis av rader for å regne ut ett tall. Regelen vi bruker: det\nsom må se dataene, går til databasen — filtrering, telling, en skriving som\navhenger av hva som er der — og forretningsregler blir i applikasjonen, fordi\ndatabasens CPU er den vanskeligste i systemet å få mer av.\n\n**Oppdateringer som blir på siden sin.** En rad som endres mange ganger i\nminuttet, etterlater en ny versjon av seg selv hver gang. Når en oppdatering ikke\nendrer noen indeksert kolonne og siden har plass, beholder PostgreSQL den nye\nversjonen på samme side og rører ingen indeks i det hele tatt: en heap-only\ntuple, eller HOT-oppdatering. Hold derfor kolonnene en hyppig oppdatering\nendrer, utenfor indeksene, og la det være plass igjen på sidene:\n\n```sql\nALTER TABLE units SET (fillfactor = 90);\n```\n\nInnstillingen gjelder sider som skrives fra da av, så sett den før radene lastes\ninn. På tabellen ovenfor var alle 2 000 reservasjoner som satte `reserved`,\n`reserved_at` og `order_id`, HOT, og av 2 000 oppdateringer som satte `sold`,\nsom den partielle indeksen leser, var ingen HOT. Salg skjer én gang per enhet;\nreservasjoner kan skje mange ganger. `n_tup_hot_upd` mot `n_tup_upd` i\n`pg_stat_user_tables` viser forholdet på et system i drift.\n\n## Én rad sier hvem som var først\n\nEn enhet går til den første kjøperen hvis setning når den, og reservasjonen\nløper ut etter databasens klokke. To kolonner bærer den: `reserved`, en boolean,\nog `reserved_at`, tidspunktet den ble satt.\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 rad tilbake: denne kjøperen har den. Ingen: noen andre var først, eller den er\nsolgt. To reservasjoner på samme enhet står i kø på radlåsen dens, og på\nREAD COMMITTED, standarden i PostgreSQL, sjekker den andre `WHERE`-leddet på nytt\nmot raden den første committet, så nøyaktig én av dem får en rad tilbake. En\nreservasjon som er eldre enn ti minutter, regnes som ledig, så ingenting trenger\nå rydde den bort for at svaret skal bli riktig.\n\nDet gjør boolean-verdien alene til et ufullstendig svar. `reserved` forblir sann\netter at en reservasjon har løpt ut, og bare de to kolonnene sammen sier om en\nenhet er reservert, så hver spørring som spør, må spørre om begge. En periodisk\nopprydding som nullstiller utløpte reservasjoner, holder tabellen ærlig for alle\nsom leser `reserved` alene, men korrektheten venter aldri på den. En skranke\nholder paret 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\nBillettnotatet lagrer fristen, `held_until`, i stedet for starttidspunktet; det\ner det samme designet. Når kjøperen velger enheten — et sete, et nummerert\ntrykk — nevner setningen den, som her. Når en hvilken som helst enhet duger,\nvelger det notatets `SKIP LOCKED`-variant en som ingen andre holder.\n\n## Lesinger bort fra primærnoden\n\nMesteparten av trafikken i en nettbutikk er lesing: produktsiden, «3 igjen»,\nhandlekurven, ordrehistorikken. Ingenting av det trenger primærnoden, den ene\nmaskinen som må holdes fri for skrivinger. En strømmende replika tar de\nlesingene, og å legge til en er konfigurasjon, der en shard er et prosjekt.\n\nTo forbehold følger med. En replika ligger litt etter, så en kjøper som nettopp\nhar reservert en enhet og så leser handlekurven sin fra den, ser kanskje ikke\nreservasjonen: les det en bruker nettopp har skrevet, fra primærnoden, eller send\nden brukeren til primærnoden i noen sekunder etter hver skriving. Og en lang\nrapport på en replika kan bli avbrutt når den holder igjen endringene replikaen\nspiller av. PostgreSQL-dokumentasjonen kaller dette spørringskonflikter og lister\nopp innstillingene som veier replikaforsinkelse opp mot dem.\n\nDen billigste lesingen er en som aldri når en database. Når hver enhet av en\nvare er reservert, kan ingen kjøpe den før en reservasjon løper ut eller frigis,\nog databasen kan si nøyaktig nå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 null, er `until` øyeblikket da den tidligste reservasjonen løper\nut: legg «fullt reservert» i hurtigbufferen med det som utløpstid, aldri lenger,\nog hver besøkende fram til da blir avvist av hurtigbufferen i stedet for av\ndatabasen. Når `free` er null og `until` er tom, er hver enhet solgt, og svaret\ner endelig. En reservasjon som frigis tidlig — et avvist kort, en forlatt\nhandlekurv — sletter oppføringen i hurtigbufferen, så enheten er straks til\nsalgs igjen.\n\nHurtigbufferen sier bare nei. Et ja kommer alltid fra den betingede\n`UPDATE`-setningen ovenfor, så en utdatert hurtigbuffer kan koste et salg i noen\nsekunder og kan aldri selge en enhet to ganger. Det er billettnotatets\nhurtigbufrede «utsolgt», med en frist.\n\n## Partisjoner tabellene rundt den hete raden\n\nPartisjonering deler én tabell i flere etter en nøkkel — en måned, en\nleietaker — bak ett navn. Det er verdt å si rett ut hva den ikke gjør: den gjør\nikke én rad som det kjempes om, raskere. Den raden bor fortsatt i én partisjon,\npå én maskin, bak én lås.\n\nDet den gjør, er å holde tabellene rundt det hete punktet små. Ordrer,\nreservasjonshistorikk og hendelser vokser i det uendelige, og de fleste\nspørringer vil ha den nyeste delen:\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 spørring som angir et datointervall, leser bare partisjonene innenfor det, og\ndenne månedens indekser holder seg små nok til å ligge i minnet. Å kvitte seg med\ngamle data er ikke lenger en `DELETE` av millioner av rader, med oppblåsingen og\nvacuumkjøringen som følger, men én setning:\n\n```sql\nALTER TABLE orders\n  DETACH PARTITION orders_2025_10;\n```\n\nPrimærnøkkelen må inneholde partisjonsnøkkelen, og derfor er den\n`(id, created_at)`. En spørring som ikke angir nøkkelen, leser hver partisjon, så\npartisjoner etter det spørringene allerede filtrerer på.\n\n## Når sharding er fornuftig\n\nDet finnes én grense sharding ikke kan flytte: hver vare har én eier. En enhet\nkan ikke reserveres på to servere samtidig, så sharding flytter hele varer,\naldri halvparten av én. Når én enkelt vare vokser fra maskinen sin, deler\nbillettnotatets bøtter beholdningen dens i mindre biter, og hver bit har igjen\nnøyaktig én eier.\n\nInnenfor det kaller vi sharding fornuftig når én av disse er sann, og ikke før:\n\n- **Én maskin er full av godt arbeid.** Setningene er allerede slanke — én\n  betinget skriving hver, ingenting eksternt inne i en transaksjon,\n  oppdateringer som blir på siden sin — og primærnodens CPU eller\n  write-ahead-logg er fortsatt mettet, på den største maskinen det er verdt å\n  kjøpe, på tvers av mange varer heller enn én. Én het vare er et bøtteproblem,\n  ikke et shardproblem.\n- **Dataene har vokst fra vedlikeholdet sitt.** En sikkerhetskopi kan ikke\n  gjenopprettes innen tiden som er lovet virksomheten, en indeks kan ikke bygges\n  eller en tabell vacuumes i de stille timene, eller arbeidssettet får ikke\n  lenger plass i minnet.\n- **Isolasjon er kravet.** En leietaker hvis kontrakt eller tilsynsmyndighet\n  sier at dataene skal ligge for seg selv, eller hvis salg ikke får dele disk med\n  noen andres.\n\nKostnaden havner på alt annet. Migreringer, sikkerhetskopiering, gjenoppretting\nog rapporter må ta hensyn til separate shards; en join på tvers av shards kan\nflyttes til applikasjonskoden; og en spørring som ikke kjenner shardnøkkelen\nsin, kan måtte spørre alle. Det er regningen delene ovenfor finnes for å unngå,\nog når den først er betalt, er den vanskelig å få tilbake.\n\n## Når en unnskyldning er billigere enn en lås\n\nDet finnes et seriøst argument for å gå den andre veien. La hver server selge fra\nbeholdningen den kan se, godta at en enhet nå og da går til to kjøpere, og la\nkundeservice refundere én av dem med en unnskyldning. Forretningslogikken blir\nkonsistent over tid, bygd for de 99,9 % av forespørslene som aldri kolliderer, og\nen asynkron løkke finner kollisjonene etterpå og retter opp i dem. Til\ngjengjeld trenger butikken aldri å si «prøv igjen». Helland og Campbell legger\nfram den sterkeste formen av saken i _Building on Quicksand_: et system som\nkvitterer for arbeid før reservesystemet har fått det, gjør hvert løfte\nsannsynlighetsbasert, og bedrifter har alltid gjort opp løftene de ikke kunne\nholde, med unnskyldninger.\n\nVi er enige i det meste av det. Vi er uenige om hvor det skal brukes.\n\n**Det meste av en butikk bør være konsistent over tid.** Katalogen, søkeindeksen,\n«3 igjen»-merket, handlekurven, anbefalingene, e-postene, lagerstrømmen og\nrapportene kan alle ligge sekunder bak, og å la dem vente på primærnoden koster\nfart og kjøper ingenting. Dynamo ble bygd for nettopp dette: handlekurven til\nAmazon glemmer eller avviser aldri en «legg i handlekurven», selv mens maskiner\nsvikter, og prisen er at en sammenslåing kan bringe tilbake en vare kjøperen\nhadde fjernet. Etter reservasjonen er utsjekkingen i billettnotatet allerede\nasynkron: en saga av lokale steg, meldinger levert minst én gang, og konsumenter\nsom er idempotente, med ordren som nøkkel. En avstemmingsløkke hører hjemme i\nethvert design som snakker med en betalingsleverandør, fordi webhooks går tapt.\n\n**Reservasjonen er det ene stedet der det ikke holder.** «Sjelden» forutsetter at\nkollisjoner er sjeldne, og i et lynsalg er kollisjonene salget. En server som\nselger ut fra sitt eget bilde, fortsetter å selge til den hører hva de andre har\nsolgt, så oversalget er omtrent forsøksraten ganger replikeringsforsinkelsen. I\nen enkel simulering deler to regioner 2 000 forsøk i sekundet, hver selger ut fra\nsin egen telling og hører om den andres salg 200 millisekunder senere. Over fem\nkjøringer av et salg på 10 000 enheter solgte hver kjøring mellom 191 og 205\nenheter som ikke fantes. Regnestykket forutsier 200: forsøksraten, ganger\nforsinkelsen, ganger andelen salg gjort i den andre regionen. Med én eier per\nvare solgte den samme modellen nøyaktig beholdningen. Det skjer hver gang noe\nblir utsolgt, enten noe svikter eller ikke, og det rammer på høydepunktet, når\nflest kjøpere ser på.\n\n**Oppetiden er mindre enn den høres ut.** Gilbert og Lynch beviste avveiningen\nbak konsistens over tid: mens nettverket er partisjonert, kan et system svare\neller være konsistent, ikke begge deler. Abadis PACELC legger til den andre\nhalvdelen. Når ingenting er partisjonert, står avveiningen mellom latens og\nkonsistens, og én eier per vare, med slanke setninger, er allerede rask. Ingen av\ndesignene når 100 %: betalingsleverandøren, DNS og nettverkene mellom dem har\nsine egne driftsavbrudd. Det det strenge designet gir opp, er smalt. Når eieren\nav beholdningen til én vare ikke kan nås, slutter den varen å selge i de\nsekundene en failover tar, og delen i billettnotatet om å sette varen på pause\navgrenser pausen til varene på maskinen som feilet. Resten av butikken\nfortsetter å selge.\n\n**En unnskyldning er ikke en refusjon.** Refusjonen er den billige delen.\nKjøperen fikk ja, og kan allerede ha bestilt toget, tatt fri fra jobben og\nfortalt det til vennene sine. Å høre «utsolgt» et sekund for tidlig er en\nskuffelse. Å høre at en bekreftet ordre er trukket tilbake, er et brutt løfte.\nKundeservice er bemannet for en vanlig dag, og oversalg kommer samlet, i årets\ntravleste minutt. Før du planlegger å trekke tilbake bekreftede ordrer, spør en\nadvokat hva en bekreftelse forplikter butikken til.\n\n**Behold den asynkrone delen, og flytt den til før ja-svaret.** Det forslaget\ntreffer riktig, er at kjøperen ikke trenger å vente på en lås. Ta imot hvert\nklikk i en varig, replikert logg, én partisjon per vare, og fortell kjøperen at\nsvaret er på vei. Å ta imot et klikk avhenger da bare av loggen, og en logg som\ner replikert over tre maskiner, fortsetter å ta imot skrivinger når én av dem\nsvikter. Én eier per vare leser loggen i rekkefølge og avgjør, i\nminnehastighet, og svaret går tilbake som en melding i løpet av sekunder. Under\nen failover for den eieren venter forespørslene i loggen i stedet for å bli\navvist eller solgt to ganger. Ja-svaret er en reservasjon, og betalingen følger\netter den som i utsjekkingen i billettnotatet, så ingen betaler for en enhet de\nikke fikk. Avstemmingen skjer fortsatt, men før løftet i stedet for etter det.\n\n**Del beholdningen, ikke tellingen.** Når virksomheten trenger at regioner\nselger uten å spørre hverandre, gi hver region en kvote av beholdningen og la den\nselge fra sin egen kvote uten å spørre noen. En region som går tom for kvote, ber\nom mer, og mot slutten av salget faller kvotene sammen til én eier igjen. Bailis\nog kolleger finner ut hvilke regler servere kan overholde uten å snakke med\nhverandre, og en beholdning som ikke får gå under null, er ikke én av dem. Kvoter\nfjerner ikke den samtalen; de flytter den bort fra den hete stien, til det\nsjeldne øyeblikket da en kvote fylles på. Det er designet som er konsistent over\ntid og likevel holder invarianten. Den eneste kostnaden er halen, der en kjøper\nblir avvist i én region mens en annen region fortsatt har beholdning.\n\n**Når oversalg er riktig strategi.** Noen varer kan lages på nytt: et trykk på\nbestilling, en T-skjorte leverandøren fortsatt har, en lisensnøkkel. Å selge\nforbi tellingen er da en restordre med en ærlig dato, og konsistens over tid er\nriktig design. Flyselskaper overbooker med vilje. De kjenner andelen som ikke\nmøter opp, priser risikoen og kompenserer etter en regel skrevet på forhånd. Det\ner testen. Et oversalg er akseptabelt når virksomheten valgte størrelsen og\nbotemiddelet før salget. Det er en feil når det rammer den som tilfeldigvis\nklikket sist.\n\n**Velger du unnskyldninger, så bygg dem som betalinger.** Løkken forslaget\nbeskriver, er en refusjonsprosess, og den trenger det alt som flytter penger,\ntrenger:\n\n- **En id på hvert salg,** slik at et nytt forsøk er det samme salget, og en\n  hovedbok over salg som bare kan utvides. Beholdningstallet utledes av\n  hovedboken og redigeres aldri.\n- **En regel for hvem som beholder enheten** som du kunne forklart for kjøperen\n  som tapte. Ordne etter loggen, ikke etter klokkene på ulike servere, der noen\n  få millisekunders avvik ville avgjort hvem som får refusjonen.\n- **Kompensasjoner som er idempotente og loggført:** kanseller, annuller eller\n  refunder, gi kjøperen beskjed. De er angre-stegene i sagaen, kjørt av en\n  maskin.\n- **En frist.** Løkken må finne hvert oversalg før noe sendes, og før kjøperen\n  finner det.\n- **Et budsjett, målt.** Oversalg per salg, mot tallet virksomheten skrev under\n  på, ved siden av invarianten på det samme dashbordet, med et varsel når\n  budsjettet er brukt opp.\n\nSvaret vårt er å være konsistent over tid overalt rundt reservasjonen, streng\nved reservasjonen og asynkron i hvordan svaret når kjøperen. Design for den\nvanlige veien, men i et lynsalg er kollisjonen den vanlige veien. Vil\nvirksomheten ha noen få oversalg i bytte mot noe, så gjør det til et tall\nvirksomheten valgte, med et botemiddel skrevet før salget, og mål det.\n\n## Det vi ville sagt til den neste\n\n- **Les før du kjøper.** `pg_stat_statements` og én `EXPLAIN` svarer på flere\n  kapasitetsspørsmål enn en ny server gjør.\n- **La typene si hva dataene er.** En boolean lagret som boolean er mindre, og\n  den avviser tull.\n- **Send databasen det som må se dataene, og ikke noe annet.** Filtrering og\n  telling hører hjemme der. Forretningsregler gjør det ikke.\n- **Hurtigbufferen sier nei; bare databasen sier ja.** Da koster en utdatert\n  hurtigbuffer sekunder, aldri en enhet.\n- **Partisjonering er husarbeid.** Den holder tabellene rundt en het rad små og\n  gjør ingenting for raden.\n- **Shard når én maskin er full av godt arbeid,** ikke når den er full av\n  venting.\n- **Avstem før ja-svaret, ikke etter.** Alt rundt reservasjonen kan være\n  konsistent over tid. Reservasjonen selv, gjort på den måten, overselger med\n  forsøksraten ganger forsinkelsen, ved hvert salg.\n\n## Kilder\n\n- [PostgreSQL: pg_stat_statements](https://www.postgresql.org/docs/current/pgstatstatements.html)\n- [PostgreSQL: bruk av EXPLAIN](https://www.postgresql.org/docs/current/using-explain.html)\n- [PostgreSQL: det kumulative statistikksystemet](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: tabellpartisjonering](https://www.postgresql.org/docs/current/ddl-partitioning.html)\n- [PostgreSQL: hot standby og spørringskonflikter](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/nb/notes/optimise-before-you-shard/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"De fleste databaser som ser ut til å trenge sharding, må leses først. Rekkefølgen vår: mål, stram inn, flytt lesingene, partisjoner og shard til slutt.","formats":{"gemtext":"https://software.engineer.company/nb/notes/optimise-before-you-shard/index.gmi","gopher":"https://software.engineer.company/nb/notes/optimise-before-you-shard/gophermap","html":"https://software.engineer.company/nb/notes/optimise-before-you-shard/","json":"https://software.engineer.company/nb/notes/optimise-before-you-shard/index.json","markdown":"https://software.engineer.company/nb/notes/optimise-before-you-shard/index.md","pdf":"https://software.engineer.company/nb/notes/optimise-before-you-shard/index.pdf"},"kind":"page","language":"nb","title":"Optimaliser databasen før du sharder den","url":"https://software.engineer.company/nb/notes/optimise-before-you-shard/","version":1}