# Polars 2.0: de ce operațiunile de join nu mai păstrează ordinea rândurilor

Published: 2026-10-08

Polars 2.0 rulează colectarea pe un motor de streaming în mod implicit. Pentru join, group\_by și unpivot, versiunea nu mai garantează ordinea rândurilor de intrare decât dacă setați explicit maintain\_order sau sort. În rularea noastră pe polars 2.0.0, o operațiune de inner join cu 2.000.000 de rânduri a returnat rândurile în afara ordinii de intrare în mod implicit și a păstrat ordinea cu maintain\_order setat. Versiunea activează, de asemenea, "out-of-core spilling" și face ca afirmațiile de benchmark să fie proprii furnizorului.

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

## Ce acoperă acest videoclip

- Apelarea collect() pe o interogare leneșă utilizează acum motorul de streaming în mod implicit, care nu garantează ordinea rândurilor pentru join, group\_by și unpivot.
- Ghidul de migrare spune că ordinea nu mai este ordinea de dinainte de 2.0 și nu este garantată; recomandă o sortare explicită dacă vă bazați pe ea.
- În rularea noastră, o operațiune de inner join implicită a returnat ordinea de intrare Fals; maintain\_order="left\_right" pe join a returnat Adevărat. O mașină, o rulare, o formă de join.
- Out-of-core spilling este activat implicit: începe să scrie pe disc la aproximativ 80% din RAM, cu un buget implicit de 64 GB pe disc. Join și group\_by out-of-core sunt pe foaia de parcurs.
- collect\_schema() detectează o coloană lipsă înainte de citirea oricăror date, dar o conversie care eșuează la o singură valoare eșuează doar la collect().
- Comparația TPC-H și TPC-DS este propria rulare a furnizorului pe date derivate, iar nota de subsol spune că rezultatele nu sunt comparabile cu benchmark-urile oficiale.

## Capitole

- 0:00 De ce s-a schimbat ordinea implicită?
- 0:56 Ce promite ghidul de migrare?
- 1:17 Este benchmark-ul o luptă echitabilă?
- 1:41 Ce vedem când îl rulăm?
- 1:56 Înseamnă mai strict mai devreme?
- 2:07 Cum obțin înapoi vechea ordine?
- 2:20 Care este verdictul?

## Transcrierea tradusă

Tradus din narațiunea originală în engleză. Audio-ul și subtitrările disponibile sunt controlate de YouTube.

### De ce s-a schimbat ordinea implicită?

0:00 Crezi că o operațiune de join îți returnează rândurile în ordinea în care le-ai scris. Polars 2.0 a încetat să mai promită asta, implicit, în mod intenționat. În acest videoclip: de ce s-a schimbat implicitul? Ce a adus? Și care dintre scripturile tale se defectează primul? Acesta este The Daily Diff, din culise. Polars este o bibliotecă DataFrame open-source: un motor de tabel pe care îl apelezi din Python,

0:20 cu nucleul său scris în Rust. Este gratuit sub licența MIT și îl instalezi cu pip install polars. Un detaliu mai întâi. Comutatorul care readuce vechea ordine este un argument pentru join-ul în sine. Voi reveni la el la final. De la 2.0, collect rulează motorul de streaming implicit. Streaming-ul împarte interogarea în bucăți care rulează în paralel, iar bucățile se termină când se termină.

0:42 Pentru join, group by și unpivot, versiunea nu promite o ordine. Cine este lovit primul? Oricine compară ieșirea cu un fișier salvat, rând cu rând. Acel test poate trece pe laptopul tău și poate eșua pe o altă mașină. Apoi, ghidul de migrare.

### Ce promite ghidul de migrare?

0:57 Spune că ordinea exactă a rândurilor prezentată mai sus nu este garantată. Deci, dacă te bazezi pe ordine, sortează explicit. Out-of-core este activat și el implicit. Începe să scrie pe disc la aproximativ optzeci la sută din RAM, cu un buget de șaizeci și patru de gigabytes. Sortarea, funcțiile de fereastră și multe expresii pot scrie acum pe disc. Operațiunile de join și group-by urmează să apară.

### Este benchmark-ul o luptă echitabilă?

1:17 Polars spune că învinge DataFusion și DuckDB la benchmark-urile TPC-H și TPC-DS. Cifrele provin din propriile lor rulări, pe date derivate, iar nota lor de subsol spune că nu sunt comparabile cu rezultatele oficiale. Propriile lor cifre spun că Polars devine de aproximativ trei virgulă opt ori mai rapid de la șaisprezece nuclee la o sută nouăzeci și două, pe TPC-H. De asemenea, spun că firele suplimentare ale mașinii mari încetinesc interogările mici.

### Ce vedem când îl rulăm?

1:41 Am rulat aceeași operațiune de join de două ori pe Polars 2.0.0. Rularea implicită amestecă rândurile. Cu flag-ul, ordinea de intrare supraviețuiește. Găsiți operațiunile de join care alimentează un test. Orice operațiune de join fără o sortare după ea este o decizie de ordine a rândurilor pe care nu ați luat-o niciodată. Polars 2.0 este mai strict în ceea ce privește tipurile.

### Înseamnă mai strict mai devreme?

1:58 Verificarea schemei detectează o coloană lipsă înainte de citirea oricăror date. Nu poate detecta o conversie care eșuează pe un singur rând, deoarece acea eroare așteaptă datele. Acum bucla pe care am deschis-o.

### Cum obțin înapoi vechea ordine?

2:08 Comutatorul se află pe operațiunea de join. Setați maintain order pe join, sau adăugați o sortare după el. Ghidul sugerează sortarea. Flag-ul de join a păstrat ordinea în rularea noastră, cu ordinea părții stângi păstrată ca stânga, dreapta. Verdict, din culise: NEEDS REVIEW.

### Care este verdictul?

2:22 Aș revizui fiecare operațiune de join înainte de a face upgrade. Aveți o întrebare despre asta? Puneți-o în comentarii. Și asta e diferența pentru azi. Sunt Niko de la Axrisi. Îmbinați cu responsabilitate.

## Surse

- [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