{"canonical_url":"https://engineer.company/sv/notes/optimise-before-you-shard/","content_markdown":"# Optimera databasen innan du shardar den\n\n2026-10-14\n\nNär en databas blir långsam under last är det första förslaget oftast fler\nmaskiner. Ibland är det rätt. Oftare är den långsamma delen en handfull satser\nsom ingen har läst ännu, och att sprida datan över flera servrar sprider de\nsatserna över mer hårdvara utan att göra någon av dem billigare. Ett problem som\nser olösligt ut är ofta bara en frågeplan från ett snyggt svar, och horisontell\nskalning väljs ibland just för att ingen ska behöva läsa\nden databas du redan har *(läs den innan du köper mer av den)*.\n\nDet här är ordningen vi arbetar i innan vi delar upp något: titta, skärp, flytta\nläsningarna från primärnoden, partitionera tabellerna runt den heta punkten och\nsharda först när en maskin är full av bra arbete. Blixtrean, där varje köpare\nskriver till en enda rad, gås igenom i\n[Att sälja den sista biljetten exakt en gång](/sv/notes/selling-limited-stock-without-overselling/).\nDen här anteckningen är metoden runt den, och dess sista avsnitt tar sig an det\nmotsatta förslaget: sälj från varje server och be om ursäkt för de enheter som\nsåldes två gånger.\n\n## Titta först\n\nPostgreSQL registrerar redan det mesta som finns att veta. Ställ fyra frågor\ntill den innan du ändrar något.\n\n**Vilka satser kostar mest totalt?** `pg_stat_statements`, ett tillägg som läses\nin via `shared_preload_libraries`, sparar varje normaliserad sats med antalet\nanrop och tiden. Sortera på total tid, inte på medelvärde: en SQL-fråga på 2 ms\nsom körs en miljon gånger i timmen kostar mer än en rapport på två sekunder som\nkörs två gånger.\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**Vad gör den översta faktiskt?** `EXPLAIN (ANALYZE, BUFFERS)` kör satsen och\nvisar planen den valde, de rader varje steg verkligen returnerade mot de rader\nden väntade sig, och hur många sidor den läste. En skanning av en miljon rader\nför att returnera tio, eller en uppskattning som slår fel med en faktor hundra,\när oftast hela förklaringen. `ANALYZE` kör det den förklarar, så lägg en\nskrivning mellan `BEGIN` och `ROLLBACK`.\n\n**Vem väntar, och på vem?**\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 här under en hektisk minut betyder att transaktioner väntar på varandra,\ninte på hårdvaran, och en större maskin tar inte bort kravet på att\nuppdateringar av en och samma delade rad utförs en i taget. Fler\napplikationsservrar kan öka antalet skrivande klienter i den kön.\n\n**Arbetar servern eller jonglerar den?** Räkna de aktiva sessionerna i\n`pg_stat_activity` mot antalet kärnor. När många gånger fler sessioner är\naktiva än det finns kärnor ägnar servern sin tid åt att växla mellan dem, och en\nanslutningspool löser det innan någon hårdvara gör det. Läs sedan `n_dead_tup`\ni `pg_stat_user_tables`: en tabell med fler döda rader än levande skannas genom\nsitt eget skräp, vilket är autovacuum som halkar efter, inte en databas som är\nför liten.\n\nSkriv ned vad du hittar. Det är utgångsläget som varje senare steg mäts mot, och\ndet ärliga svaret på ”behöver vi sharda?” finns ofta redan i det.\n\n## Skärp det som redan finns\n\nUngefär i ordning efter vad det ger för insatsen.\n\n**Index som matchar frågorna.** Planerna ovan pekar ut skanningarna. Ett index\npå de kolumner som en het SQL-fråga filtrerar på gör en skanning till ett\nuppslag, och ett partiellt index rymmer bara de rader en SQL-fråga kan vilja\nha — enheter som fortfarande är till salu, till exempel — så att det krymper\nmedan en rea pågår i stället för att växa:\n\n```sql\nCREATE INDEX units_unsold\n    ON units (item_id)\n WHERE NOT sold;\n```\n\nVarje index betalas också vid varje skrivning, så ta bort dem vars `idx_scan` i\n`pg_stat_user_indexes` står kvar på noll.\n\n**Typer som säger vad värdet är.** Scheman som skrivs snabbt, av en människa\neller en modell, tar till `TEXT` där en `SMALLINT` eller en `BOOLEAN` skulle\nräcka. En `BOOLEAN` är en byte, en `SMALLINT` två, och `'yes'` lagrat som text\när fyra. PostgreSQL lägger också in utfyllnad så att varje kolumn med fast bredd\nhamnar på sin egen justeringsgräns, så en kolumnordning som har valts av en\nslump kostar också byte. En lagerenhet, snabbt skriven:\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\nOch samma enhet med typer som säger vad värdena är, bredast 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äter den första raden 72 byte och den andra 54, en fjärdedel\nmindre, så mer av tabellen ryms i minnet. Typerna vägrar också värden som\n`'maybe'` som applikationen annars skulle behöva försvara sig mot, och ett\n`CHECK`-villkor gör samma sak för intervall: `quantity smallint CHECK (quantity \u003e 0)`.\n\n**Färre nätverksrundor, och arbetet där datan finns.** Varje sats som\napplikationen skickar kostar en nätverksrunda och en parsning. En loop som läser\nhundra rader och uppdaterar dem en i taget är hundraen nätverksrundor där en\nenda mängdbaserad sats skulle räcka, och en sida som hämtar varje enhet av en\nvara för att räkna de lediga skickar tusentals rader för att räkna ut ett enda\ntal. Regeln vi följer: det som måste se datan går till databasen — filtrering,\nräkning, en skrivning som beror på vad som finns där — och affärsregler stannar\ni applikationen, eftersom databasens CPU är den som är svårast att få mer av i\nhela systemet.\n\n**Uppdateringar som stannar på sin sida.** En rad som ändras många gånger i\nminuten lämnar en ny version av sig själv efter sig varje gång. När en\nuppdatering inte ändrar någon indexerad kolumn och sidan har plats, behåller\nPostgreSQL den nya versionen på samma sida och rör inget index alls: en\nheap-only tuple, eller HOT-uppdatering. Håll därför de kolumner som en frekvent\nuppdatering ändrar utanför indexen, och lämna plats på sidorna:\n\n```sql\nALTER TABLE units SET (fillfactor = 90);\n```\n\nInställningen gäller sidor som skrivs från och med då, så sätt den innan raderna\nläses in. På tabellen ovan var 2 000 reservationer som satte `reserved`,\n`reserved_at` och `order_id` alla HOT, och av 2 000 uppdateringar som satte\n`sold`, som det partiella indexet läser, var ingen HOT. En försäljning sker en\ngång per enhet; en reservation kan ske många gånger. `n_tup_hot_upd` mot\n`n_tup_upd` i `pg_stat_user_tables` visar kvoten i ett system i drift.\n\n## En rad säger vem som var först\n\nEn enhet går till den första köpare vars sats når den, och reservationen löper\nut enligt databasens klocka. Två kolumner bär den: `reserved`, en boolean, och\n`reserved_at`, tidpunkten då den sattes.\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\nEn rad tillbaka: den här köparen har den. Ingen: någon annan var först, eller så\när den såld. Två reservationer av samma enhet köar på dess radlås, och med READ\nCOMMITTED, standardnivån i PostgreSQL, kontrollerar den andra `WHERE`-villkoret\nigen mot raden som den första committade, så att exakt en av dem får en rad\ntillbaka. En reservation som är äldre än tio minuter räknas som ledig, så\ningenting behöver städa bort den för att svaret ska bli rätt.\n\nDet gör booleanen ensam till ett ofullständigt svar. `reserved` förblir true\nefter att en reservation har löpt ut, och bara de två kolumnerna tillsammans\nsäger om en enhet är reserverad, så varje SQL-fråga som vill veta det måste\nfråga efter båda. En periodisk städning som nollställer utgångna reservationer\nhåller tabellen ärlig för den som läser `reserved` ensam, men korrektheten\nväntar aldrig på den. Ett villkor håller 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\nBiljettanteckningen lagrar tidsgränsen, `held_until`, i stället för starten;\ndet är samma lösning. När köparen väljer enheten — en sittplats, ett numrerat\ntryck — namnger satsen den, som här. När vilken enhet som helst duger väljer\nden anteckningens `SKIP LOCKED`-form en som ingen annan håller.\n\n## Flytta läsningarna från primärnoden\n\nDet mesta av en butiks trafik är läsning: produktsidan, ”3 kvar”, varukorgen,\norderhistoriken. Inget av det behöver primärnoden, den enda maskin som måste\nhållas fri för skrivningar. En strömmande replik tar de läsningarna, och att\nlägga till en är konfiguration där en shard är ett projekt.\n\nTvå förbehåll följer med. En replik ligger lite efter, så en köpare som just har\nreserverat en enhet och sedan läser sin varukorg från den kanske inte ser\nreservationen: läs det en användare just har skrivit från primärnoden, eller\nskicka den användaren till primärnoden i några sekunder efter varje skrivning.\nOch en lång rapport på en replik kan avbrytas när den håller upp ändringarna som\nrepliken spelar upp. PostgreSQL-dokumentationen kallar det frågekonflikter och\nlistar de inställningar som väger replikens eftersläpning mot dem.\n\nDen billigaste läsningen är en som aldrig når en databas. När varje enhet av en\nvara är reserverad kan ingen köpa den förrän en reservation löper ut eller\nsläpps, och databasen kan säga exakt när det sker:\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` är noll är `until` tidpunkten då den tidigaste reservationen löper\nut: cacha ”fullt reserverad” med den som utgångstid, aldrig längre, så avvisas\nvarje besökare fram till dess av cachen i stället för av databasen. När `free`\när noll och `until` är tom är varje enhet såld och svaret slutgiltigt. En\nreservation som släpps i förtid — ett nekat kort, en övergiven varukorg — tar\nbort cacheposten, så att enheten genast är till salu igen.\n\nCachen säger aldrig något annat än nej. Ett ja kommer alltid från den villkorade\n`UPDATE` ovan, så en inaktuell cache kan kosta en försäljning i några sekunder\noch kan aldrig sälja en enhet två gånger. Det är biljettanteckningens cachade\n”slutsålt”, med en tidsgräns.\n\n## Partitionera tabellerna runt den heta raden\n\nPartitionering delar upp en tabell i flera efter en nyckel — en månad, en\ntenant — bakom ett enda namn. Det är värt att säga rakt ut vad den inte gör: den\ngör inte en rad som flera transaktioner konkurrerar om något snabbare. Den raden finns fortfarande i en\npartition, på en maskin, bakom ett lås.\n\nDet den gör är att hålla tabellerna runt den heta punkten små. Ordrar,\nreservationshistorik och händelser växer för alltid, och de flesta SQL-frågor\nvill ha den senaste 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 SQL-fråga som anger ett datumintervall läser bara partitionerna inom det, och\nden här månadens index förblir små nog att ligga i minnet. Gallring slutar\nvara en `DELETE` av miljontals rader, med den uppsvällning och vacuum-körning\nsom följer, och blir en enda sats:\n\n```sql\nALTER TABLE orders\n  DETACH PARTITION orders_2025_10;\n```\n\nPrimärnyckeln måste innehålla partitionsnyckeln, och därför är den\n`(id, created_at)`. En SQL-fråga som inte anger nyckeln läser varje partition,\nså partitionera på det som SQL-frågorna redan filtrerar på.\n\n## När sharding är rimligt\n\nDet finns en gräns som sharding inte kan flytta: varje vara har en ägare. En\nenhet kan inte reserveras på två servrar samtidigt, så sharding flyttar hela\nvaror, aldrig halva. När en enda vara växer ur sin maskin delar\nbiljettanteckningens hinkar upp dess lagersaldo i mindre delar, och varje del\nhar återigen exakt en ägare.\n\nInom den ramen kallar vi sharding rimligt när något av följande stämmer, och\ninte förr:\n\n- **En maskin är full av bra arbete.** Satserna är redan slimmade — en villkorad\n  skrivning var, ingenting externt inuti en transaktion, uppdateringar som\n  stannar på sin sida — och primärnodens CPU eller write-ahead-logg är ändå\n  mättad, på den största maskin som är värd att köpa, över många varor snarare\n  än en. En het vara är ett hinkproblem, inte ett shardproblem.\n- **Datan har vuxit ur sitt underhåll.** En säkerhetskopia kan inte återställas\n  inom den tid som verksamheten har blivit lovad, ett index kan inte byggas\n  eller en tabell städas med vacuum under de lugna timmarna, eller så ryms\n  arbetsmängden inte längre i minnet.\n- **Isolering är kravet.** En tenant vars avtal eller tillsynsmyndighet säger\n  att dess data ska ligga för sig, eller vars rea inte får dela disk med någon\n  annans.\n\nKostnaden hamnar på allt annat. Migreringar, säkerhetskopiering, återställning\noch rapporter måste ta hänsyn till separata shards; en join över shards kan\nflyttas till applikationskoden; och en SQL-fråga som inte känner till sin\nshardnyckel kan behöva fråga alla. Det är den nota som avsnitten ovan finns till\nför att undvika, och när den väl är betald är det svårt att ta sig tillbaka.\n\n## När en ursäkt är billigare än ett lås\n\nDet finns ett seriöst argument för att gå åt andra hållet. Låt varje server\nsälja av det lager den ser, acceptera att en enhet då och då går till två\nköpare, och låt kundtjänst återbetala en av dem med en ursäkt. Affärslogiken\nblir slutligt konsistent, byggd för de 99,9 % av begärandena som aldrig krockar,\noch en asynkron loop hittar krockarna i efterhand och gottgör dem. I gengäld\nbehöver butiken aldrig säga ”försök igen”. Helland och Campbell för fram den\nstarkaste formen av argumentet i _Building on Quicksand_: ett system som\nbekräftar arbete innan dess reservnod har fått det gör varje löfte\nprobabilistiskt, och företag har i alla tider gjort upp om löften de inte kunnat\nhålla genom att be om ursäkt.\n\nVi håller med om det mesta av det. Vi är oense om var det ska tillämpas.\n\n**Det mesta av en butik bör vara slutligt konsistent.** Katalogen, sökindexet,\nmärket med ”3 kvar”, varukorgen, rekommendationerna, e-postmeddelandena, flödet\ntill lagret och rapporterna kan alla ligga sekunder efter, och att låta dem\nvänta på primärnoden kostar snabbhet och köper ingenting. Dynamo byggdes för\njust detta: Amazons kundvagn glömmer eller avvisar aldrig ett ”lägg i\nkundvagnen”, inte ens när maskiner fallerar, och priset är att en sammanslagning\nkan återställa en vara som köparen hade tagit bort. Efter reservationen är\nbiljettanteckningens köpflöde redan asynkront: en saga av lokala steg,\nmeddelanden som levereras minst en gång, och konsumenter som är idempotenta,\nnycklade på ordern. En avstämningsloop hör hemma i varje lösning som talar med\nen betalningsleverantör, eftersom webhooks går förlorade.\n\n**Reservationen är det enda ställe där det inte håller.** ”Sällsynt” förutsätter\natt krockar är sällsynta, och i en blixtrea är krockarna själva rean. En server\nsom säljer utifrån sin egen bild fortsätter sälja tills den hör vad de andra\nsålde, så översäljningen blir ungefär försöksfrekvensen gånger\nreplikeringsfördröjningen. I en enkel simulering delar två regioner på\n2 000 försök i sekunden, var och en säljer utifrån sin egen räkning och hör om\nden andras försäljningar 200 millisekunder senare. Över fem körningar av en rea\npå 10 000 enheter sålde varje körning mellan 191 och 205 enheter som inte\nfanns. Räknestycket förutsäger 200: försöksfrekvensen, gånger fördröjningen,\ngånger andelen försäljningar som görs i den andra regionen. Med en ägare per\nvara sålde samma modell exakt lagret. Det händer varje gång något säljer slut,\noavsett om något gick sönder eller inte, och det inträffar vid klimax, när flest\nköpare tittar.\n\n**Upptiden är mindre än den låter.** Gilbert och Lynch bevisade den\navvägning som slutlig konsistens gör: medan nätverket är partitionerat kan ett\nsystem svara eller vara konsistent, inte båda. Abadis PACELC lägger till den\nandra halvan. När ingenting är partitionerat är avvägningen latens mot\nkonsistens, och en ägare per vara, med slimmade satser, är redan snabb. Ingen av\nlösningarna når 100 %: betalningsleverantören, DNS och nätverken mellan dem har\nsina egna avbrott. Det den strikta lösningen ger upp är smalt. När ägaren av en\nvaras lagersaldo inte går att nå slutar den varan att säljas under de sekunder\nsom en failover tar, och biljettanteckningens avsnitt om att pausa varan\navgränsar pausen till varorna på maskinen som gick ned. Resten av butiken\nfortsätter sälja.\n\n**En ursäkt är inte en återbetalning.** Återbetalningen är den billiga delen.\nKöparen fick ett ja, och kan redan ha bokat tåget, tagit ledigt och berättat för\nsina vänner. Att höra ”slutsålt” en sekund för tidigt är en besvikelse. Att höra\natt en bekräftad order har dragits tillbaka är ett sviket löfte. Kundtjänst är\nbemannad för en vanlig dag, och översäljningar kommer samtidigt, under årets\nmest hektiska minut. Innan du planerar att dra tillbaka bekräftade ordrar, fråga\nen jurist vad en bekräftelse förpliktar butiken till.\n\n**Behåll den asynkrona delen, och flytta den före jaet.** Det som förslaget har\nrätt i är att köparen inte behöver vänta på ett lås. Ta emot varje klick i en\nbeständig, replikerad logg, en partition per vara, och säg till köparen att\nsvaret är på väg. Att ta emot ett klick beror då bara på loggen, och en logg som\nreplikeras över tre maskiner fortsätter ta emot skrivningar när en av dem går\nsönder. En ägare per vara läser loggen i ordning och avgör, i minnets\nhastighet, och svaret går tillbaka som ett meddelande inom några sekunder. När\nden ägaren gör failover väntar begärandena i loggen i stället för att avvisas\neller säljas två gånger. Jaet är en reservation, och betalningen följer på den\nsom i biljettanteckningens köpflöde, så ingen betalar för en enhet utan att\nfå den. Avstämningen sker fortfarande, men före löftet i stället för efter det.\n\n**Dela lagret, inte räkningen.** När verksamheten behöver att regioner säljer\nutan att fråga varandra, ge varje region en kvot av lagret och låt den sälja av\nsin egen kvot utan att fråga någon. En region vars kvot tar slut ber om mer, och\nmot slutet av rean slås kvoterna ihop till en ägare igen. Bailis med kolleger\nreder ut vilka regler servrar kan upprätthålla utan att tala med varandra, och\nett lagersaldo som inte får gå under noll är inte en av dem. Kvoter tar inte\nbort det samtalet; de flyttar det bort från den heta vägen, till det sällsynta\nögonblick då en kvot fylls på. Det är den slutligt konsistenta lösning som\nbehåller invarianten. Dess enda kostnad är svansen, där en köpare avvisas i en\nregion medan en annan region fortfarande har lager.\n\n**När en översäljning är rätt policy.** Vissa varor kan tillverkas igen: ett\ntryck på beställning, en t-shirt som leverantören fortfarande har, en\nlicensnyckel. Att sälja förbi räkningen är då en restorder med ett ärligt datum,\noch slutlig konsistens är rätt lösning. Flygbolag överbokar med flit. De känner\ntill hur stor andel av passagerarna som uteblir, prissätter risken och\nkompenserar enligt en regel som är skriven i förväg. Det är testet. En\növersäljning är acceptabel när verksamheten valde dess storlek och dess\ngottgörelse före rean. Den är en defekt när den drabbar den som råkade klicka\nsist.\n\n**Om du väljer ursäkter, bygg dem som betalningar.** Loopen som förslaget\nbeskriver är en kedja för återbetalningar, och den behöver det som allt som\nflyttar pengar behöver:\n\n- **Ett id på varje försäljning,** så att ett omförsök är samma försäljning, och\n  en liggare över försäljningar där poster bara läggs till. Lagersaldot härleds\n  ur liggaren och redigeras aldrig.\n- **En regel för vem som behåller enheten** som du skulle kunna förklara för den\n  köpare som förlorade. Ordna efter loggen, inte efter klockorna på olika\n  servrar, där några millisekunders avvikelse skulle avgöra vem som får\n  återbetalningen.\n- **Kompensationer som är idempotenta och loggade:** avbryt, annullera eller\n  återbetala, meddela köparen. De är sagans ångra-steg, körda av en maskin.\n- **En tidsgräns.** Loopen måste hitta varje översäljning innan något skickas,\n  och innan köparen hittar den.\n- **En budget, mätt.** Översäljningar per rea, mot det tal som verksamheten\n  skrev under på, bredvid invarianten på samma instrumentpanel, med ett larm när\n  budgeten är förbrukad.\n\nVårt svar är att vara slutligt konsistent överallt runt reservationen, strikt\nvid reservationen och asynkron i hur svaret når köparen. Bygg för det vanliga\nfallet, men i en blixtrea är krocken det vanliga fallet. Om verksamheten vill ha\nnågra översäljningar i utbyte mot något, gör det till ett tal som verksamheten\nhar valt, med en gottgörelse som är skriven före rean, och mät det.\n\n## Vad vi skulle säga till nästa person\n\n- **Läs innan du köper.** `pg_stat_statements` och en enda `EXPLAIN` besvarar\n  fler kapacitetsfrågor än en ny server gör.\n- **Låt typerna säga vad datan är.** En boolean som lagras som boolean är\n  mindre, och den vägrar nonsens.\n- **Skicka till databasen det som måste se datan, och inget annat.** Filtrering\n  och räkning hör hemma där. Affärsregler gör det inte.\n- **Cachen säger nej; bara databasen säger ja.** Då kostar en inaktuell cache\n  sekunder, aldrig en enhet.\n- **Partitionering är städning.** Den håller tabellerna runt en het rad små och\n  gör ingenting för raden.\n- **Sharda när en maskin är full av bra arbete,** inte när den är full av\n  väntan.\n- **Stäm av före jaet, inte efter.** Allt runt reservationen kan vara slutligt\n  konsistent. Själva reservationen, gjord på det sättet, översäljer med\n  försöksfrekvensen gånger fördröjningen, vid varje rea.\n\n## Källor\n\n- [PostgreSQL: pg_stat_statements](https://www.postgresql.org/docs/current/pgstatstatements.html)\n- [PostgreSQL: att använda EXPLAIN](https://www.postgresql.org/docs/current/using-explain.html)\n- [PostgreSQL: det kumulativa statistiksystemet](https://www.postgresql.org/docs/current/monitoring-stats.html)\n- [PostgreSQL: numeriska typer](https://www.postgresql.org/docs/current/datatype-numeric.html)\n- [PostgreSQL: teckentyper](https://www.postgresql.org/docs/current/datatype-character.html)\n- [PostgreSQL: typen boolean](https://www.postgresql.org/docs/current/datatype-boolean.html)\n- [PostgreSQL: partiella index](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: tabellpartitionering](https://www.postgresql.org/docs/current/ddl-partitioning.html)\n- [PostgreSQL: hot standby och frågekonflikter](https://www.postgresql.org/docs/current/hot-standby.html)\n- [Pat Helland och Dave Campbell, Building on Quicksand](https://arxiv.org/abs/0909.1788)\n- [Seth Gilbert och 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 och 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/sv/notes/optimise-before-you-shard/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"De flesta databaser som verkar behöva shardas behöver först läsas. Vår arbetsordning: mät, skärp, flytta bort läsningar, partitionera, sharda sedan.","formats":{"gemtext":"https://data.engineer.company/sv/notes/optimise-before-you-shard/index.gmi","gopher":"https://data.engineer.company/sv/notes/optimise-before-you-shard/gophermap","html":"https://data.engineer.company/sv/notes/optimise-before-you-shard/","json":"https://data.engineer.company/sv/notes/optimise-before-you-shard/index.json","markdown":"https://data.engineer.company/sv/notes/optimise-before-you-shard/index.md","pdf":"https://data.engineer.company/sv/notes/optimise-before-you-shard/index.pdf"},"kind":"page","language":"sv","title":"Optimera databasen innan du shardar den","url":"https://data.engineer.company/sv/notes/optimise-before-you-shard/","version":1}