# Polars 2.0: varför kopplingar inte längre behåller sin radordning

Published: 2026-10-08

Polars 2.0 kör collect på en strömmande motor som standard. För join, group\_by och unpivot garanterar versionen inte längre indata-radordning om du inte uttryckligen ställer in maintain\_order eller sort. I vår körning på Polars 2.0.0 returnerade en inre koppling med 2 000 000 rader rader i annan ordning än inmatningsordningen som standard och behöll ordningen när maintain\_order var inställt. Versionen aktiverar också ut-ur-kärnans spillning och gör prestandajämförelserna till leverantörens egna påståenden.

Canonical: https://thedailydiff.dev/sv/video/polars-2-row-order/

## Vad den här videon täcker

- Att anropa collect() på en lat fråga använder nu strömmande motorn som standard, vilket inte garanterar radordning för join, group\_by och unpivot.
- Migrationsguiden säger att ordningen inte längre är den före 2.0-ordningen och inte garanteras; den rekommenderar en explicit sortering om du förlitar dig på den.
- I vår körning returnerade en standardinre koppling indataordning False; maintain\_order="left\_right" på kopplingen returnerade True. En maskin, en körning, en kopplingsform.
- Ut-ur-kärnans spillning är på som standard: den börjar vid cirka 80 % av RAM, med en standarddiskbudget på 64 GB. Ut-ur-kärnans koppling och group\_by finns på färdplanen.
- collect\_schema() fångar en saknad kolumn innan några data läses, men en cast som misslyckas på bara ett värde misslyckas först vid collect().
- TPC-H- och TPC-DS-jämförelsen är leverantörens egen körning på härledd data, och dess fotnot säger att resultaten inte är jämförbara med officiella prestandatester.

## Kapitel

- 0:00 Varför ändrades standardordningen?
- 0:56 Vad lovar migrationsguiden?
- 1:17 Är jämförelsen rättvis?
- 1:41 Vad ser vi när vi kör det?
- 1:56 Betyder striktare tidigare?
- 2:07 Hur får jag tillbaka den gamla ordningen?
- 2:20 Vad blir domen?

## Översatt transkription

Översatt från den ursprungliga engelska berättelsen. Tillgängligt ljud och undertexter styrs av YouTube.

### Varför ändrades standardordningen?

0:00 Du tror att en koppling returnerar dina rader i den ordning du skrev dem. Polars 2.0 slutade lova det, som standard, med avsikt. I den här videon: varför ändrades standardinställningen? Vad köpte det? Och vilket av dina skript går sönder först? Detta är The Daily Diff, under huven. Polars är ett open source DataFrame-bibliotek: en tabellmotor som du anropar från Python,

0:20 med sin kärna skriven i Rust. Det är gratis under MIT-licensen, och du installerar det med pip install polars. En detalj först. Brytaren som återställer den gamla ordningen är ett argument till själva kopplingen. Jag återkommer till det i slutet. Sedan 2.0 kör collect den strömmande motorn som standard. Streaming delar upp frågan i bitar som körs parallellt, och bitarna avslutas när de avslutas.

0:42 För join, group by och unpivot lovar versionen ingen ordning. Vem drabbas först? Den som jämför utdata med en sparad fil, rad för rad. Det testet kan passera på din laptop och misslyckas på en annan maskin. Nästa, migrationsguiden.

### Vad lovar migrationsguiden?

0:57 Den säger att den exakta radordningen som visas ovan inte garanteras. Så om du förlitar dig på ordningen, sortera explicit. Ut-ur-kärnans spillning är också på som standard. Den börjar spilla till disk vid cirka åttio procent av RAM, med en budget på sextiofyra gigabyte. Sortering, fönsterfunktioner och många uttryck kan nu spilla. Kopplingar och group-bys är på gång.

### Är jämförelsen rättvis?

1:17 Polars säger att det slår DataFusion och DuckDB i TPC-H och TPC-DS prestandatester. Siffrorna kommer från deras egna körningar, på härledd data, och deras fotnot säger att de inte är jämförbara med officiella resultat. Deras egna siffror säger att Polars blir cirka tre komma åtta gånger snabbare från sexton kärnor till etthundranittiotvå, på TPC-H. De säger också att den stora maskinens extra trådar saktar ner små frågor.

### Vad ser vi när vi kör det?

1:41 Vi körde samma koppling två gånger på Polars 2.0.0. Standardkörningen blandar om raderna. Med flaggan överlever indataordningen. Hitta kopplingarna som matar ett test. Varje koppling utan en sortering efter den är ett radordningsbeslut du aldrig fattat. Polars 2.0 är striktare med typer.

### Betyder striktare tidigare?

1:58 Schemakontrollen fångar en saknad kolumn innan några data läses. Den kan inte fånga en cast som misslyckas på en rad, eftersom det felet väntar på datan. Nu slingan jag öppnade.

### Hur får jag tillbaka den gamla ordningen?

2:08 Brytaren sitter på kopplingen. Ställ in maintain order på kopplingen, eller lägg till en sortering efter den. Guiden föreslår sorteringen. Kopplingsflaggan behöll ordningen i vår körning, med vänster sida:s ordning behållen som vänster, höger. Dom, under huven: behöver granskas.

### Vad blir domen?

2:22 Jag skulle granska varje koppling innan uppgradering. Har du en fråga om detta? Skriv den i kommentarerna. Och det var The Daily Diff för idag. Jag är Niko från Axrisi. Sammanfoga ansvarsfullt.

## Källor

- [Release of Polars 2.0](https://pola.rs/posts/release-polars-2/) — Polars (pola.rs)
- [Polars 2.0 upgrade guide](https://docs.pola.rs/releases/upgrade/2/) — Polars documentation
- [Polars homepage](https://pola.rs/) — Polars (pola.rs)
- [polars-2.0-benchmark repository](https://github.com/pola-rs/polars-2.0-benchmark) — Polars on GitHub
- [Release of Polars 2.0 (Hacker News discussion)](https://news.ycombinator.com/item?id=49977177) — Hacker News