+− THE DAILY DIFFdev & AI news
NEEDS REVIEW

Polars 2.0: hvorfor joins ikke lenger beholder radrekkefølgen sin

Polars 2.0 kjører collect på en strømmemotor som standard.

Want to see our stories first on Google? Add us to your preferred sources — it helps us grow.

Polars 2.0 kjører collect på en strømmemotor som standard. For join, group_by og unpivot garanterer ikke lenger utgivelsen inputradrekkefølge med mindre du eksplisitt angir maintain_order eller sort. I vår kjøring på Polars 2.0.0 returnerte en indre join med 2 000 000 rader rader ut av inputrekkefølge som standard og beholdt rekkefølgen med maintain_order satt. Utgivelsen slår også på "out-of-core spilling" og gjør benchmark-påstandene til leverandørens egne.

Les den skriftlige utgaven (engelsk) ↗

Hva denne videoen dekker

  • Kall av collect() på en "lazy query" bruker nå strømmemotoren som standard, som ikke garanterer radrekkefølge for join, group_by og unpivot.
  • Migrasjonsguiden sier at rekkefølgen ikke lenger er rekkefølgen før 2.0 og er ikke garantert; den anbefaler en eksplisitt sortering hvis du er avhengig av det.
  • I vår kjøring returnerte en standard indre join inputrekkefølge False; maintain_order="left_right" på join returnerte True. Én maskin, én kjøring, én join-form.
  • Out-of-core spilling er på som standard: den starter på omtrent 80 % av RAM, med et standard diskbudsjett på 64 GB. Out-of-core join og group_by er på veikartet.
  • collect_schema() fanger en manglende kolonne før noen data leses, men en "cast" som mislykkes på bare én verdi, mislykkes først ved collect().
  • TPC-H- og TPC-DS-sammenligningen er leverandørens egen kjøring på avledede data, og fotnoten sier at resultatene ikke kan sammenlignes med offisielle benchmarks.

Spørsmål og svar

Hvorfor beholder ikke Polars 2.0-koblinger rader i sin inndatarekkefølge lenger?

Å kalle collect på en lat spørring bruker nå strømmemotoren som standard. Strømming deler spørringen inn i biter som kjører parallelt, og bitene fullføres når de fullføres. For join, group_by og unpivot lover utgivelsen derfor ikke en utdata-radrekkefølge. Tester som sammenligner utdata med en lagret fil rad for rad er de første som sannsynligvis vil bryte.

Se denne delen 0:00 · Polars (pola.rs) · Polars documentation

Hvordan får jeg tilbake den gamle radrekkefølgen etter oppgradering til Polars 2.0?

Legg til en eksplisitt sortering etter koblingen, som er det migreringsguiden anbefaler, eller sett argumentet maintain_order på koblingen. I episodens kjøring på Polars 2.0.0 returnerte en standard indre kobling rader ut av inndatarekkefølge, mens maintain_order satt til left_right beholdt rekkefølgen. Det var én maskin, én kjøring og én koblingsform.

Se denne delen 2:07 · Polars documentation

Kan Polars 2.0 behandle data større enn minnet?

Delvis. Ut-av-kjerne-spilling er på som standard, fra rundt 80 % av RAM med et standard diskbudsjett på 64 GB. Sortering, vindusfunksjoner og mange uttrykk kan nå spilles ut. Ut-av-kjerne-koblinger og grupper er på veikartet, så disse operasjonene spilles ikke ut ennå.

Se denne delen 0:56 · Polars (pola.rs) · Polars documentation

Kan jeg stole på Polars 2.0 benchmark-sammenligningene med DuckDB og DataFusion?

Behandle dem som leverandørens egne påstander. Polars sier det slår DataFusion og DuckDB på TPC-H og TPC-DS, men tallene kommer fra egne kjøringer på avledede data, og fotnoten sier at resultatene ikke kan sammenlignes med offisielle benchmarks. Polars sier også at den store maskinens ekstra tråder bremser ned små spørringer.

Se denne delen 1:17 · Polars (pola.rs) · Polars on GitHub

Er det trygt å oppgradere eksisterende Polars-pipelines til versjon 2.0?

The Daily Diffs dom var NEEDS REVIEW. Episoden ville gjennomgå hver kobling før oppgradering, fordi enhver kobling uten en sortering etter den er en radrekkefølgebeslutning som aldri er tatt. Strengere typing hjelper litt, siden skjema-sjekken fanger opp en manglende kolonne før data leses, men en casting som mislykkes på bare én rad, mislykkes bare ved collect.

Se denne delen 2:20 · Polars documentation · Polars (pola.rs)

Oversatt transkripsjon

Oversatt fra den originale engelske fortellingen. Tilgjengelig lyd og undertekster kontrolleres av YouTube.

Hvorfor endret standardrekkefølgen seg?

0:00 Du tror en join gir deg radene tilbake i den rekkefølgen du skrev dem. Polars 2.0 sluttet å love det, som standard, med vilje. I denne videoen: hvorfor endret standarden seg? Hva kjøpte den? Og hvilket av skriptene dine ryker først? Dette er The Daily Diff, under panseret. Polars er et åpen kildekode DataFrame-bibliotek: en tabellmotor du kaller fra Python,

0:20 med kjernen skrevet i Rust. Det er gratis under MIT-lisensen, og du installerer det med pip install polars. Én detalj først. Bryteren som bringer den gamle rekkefølgen tilbake er et argument til selve joinen. Jeg kommer tilbake til det på slutten. Siden 2.0 kjører collect strømmemotoren som standard. Strømming deler spørringen i biter som kjører parallelt, og bitene fullføres når de fullføres.

0:42 For join, group by og unpivot lover ikke utgivelsen en rekkefølge. Hvem blir rammet først? Den som sammenligner utdata med en lagret fil, rad for rad. Den testen kan bestå på din laptop og feile på en annen maskin. Deretter migrasjonsguiden.

Hva lover migrasjonsguiden?

0:57 Den sier at den eksakte radrekkefølgen vist ovenfor ikke er garantert. Så hvis du er avhengig av rekkefølgen, sorter eksplisitt. Out-of-core er også på som standard. Den begynner å "spille" til disk ved omtrent åtti prosent av RAM, med et sekstifire gigabyte budsjett. Sort, vindusfunksjoner og mange uttrykk kan "spill" nå. Joins og group-bys kommer.

Er benchmarken en rettferdig kamp?

1:17 Polars sier det slår DataFusion og DuckDB på TPC-H og TPC-DS benchmarks. Tallene kommer fra deres egne kjøringer, på avledede data, og fotnoten deres sier at de ikke kan sammenlignes med offisielle resultater. Deres egne tall sier at Polars blir omtrent tre komma åtte ganger raskere fra seksten kjerner til et hundre nittito, på TPC-H. De sier også at den store maskinens ekstra tråder bremser små spørringer.

Hva ser vi når vi kjører den?

1:41 Vi kjørte den samme join to ganger på Polars 2.0.0. Standard kjøring stokker om radene. Med flagget overlever inputrekkefølgen. Finn joins som mater en test. Enhver join uten en sortering etterpå er en radrekkefølgebeslutning du aldri tok. Polars 2.0 er strengere med typer.

Betyr strengere tidligere?

1:58 Skjemakontrollen fanger en manglende kolonne før noen data leses. Den kan ikke fange en "cast" som mislykkes på én rad, fordi den feilen venter på dataene. Nå loopen jeg åpnet.

Hvordan får jeg tilbake den gamle rekkefølgen?

2:08 Bryteren sitter på joinen. Sett "maintain order" på joinen, eller legg til en sortering etterpå. Guiden foreslår sorteringen. Join-flagget beholdt rekkefølgen i vår kjøring, med venstre sides rekkefølge beholdt som venstre, høyre. Dom, under panseret: NEEDS REVIEW.

Hva er dommen?

2:22 Jeg ville gjennomgått hver join før oppgradering. Har du et spørsmål om dette? Legg det i kommentarene. Og det er The Daily Diff for i dag. Jeg er Niko fra Axrisi. Flett ansvarlig.

Kilder

  1. Release of Polars 2.0Polars (pola.rs)
  2. Polars 2.0 upgrade guidePolars documentation
  3. Polars homepagePolars (pola.rs)
  4. polars-2.0-benchmark repositoryPolars on GitHub
  5. Release of Polars 2.0 (Hacker News discussion)Hacker News

Niko from Axrisi

Nikoloz Turazashvili · Vexrail · Axrisi

LinkedIn · dev.to · GitHub · X · Substack

Relaterte videoer