# ପୋଲାର୍ସ 2.0: କାହିଁକି ଯୋଗଦାନଗୁଡ଼ିକ ଆଉ ସେମାନଙ୍କର ଧାଡି କ୍ରମ ରଖନ୍ତି ନାହିଁ

Published: 2026-10-08

Polars 2.0 ଡିଫଲ୍ଟ ଭାବରେ ଏକ ଷ୍ଟ୍ରିମିଂ ଇଞ୍ଜିନ୍‌ରେ collect ଚଳାଏ। join, group\_by ଏବଂ unpivot ପାଇଁ, ମୁକ୍ତଟି ଆଉ ଇନପୁଟ୍ ଧାଡି କ୍ରମର ଗ୍ୟାରେଣ୍ଟି ଦିଏ ନାହିଁ, ଯଦି ନାହିଁ ଆପଣ maintain\_order କିମ୍ବା sort ସ୍ପଷ୍ଟ ଭାବରେ ସେଟ୍ କରନ୍ତି। Polars 2.0.0 ରେ ଆମର ଚାଲୁଥିବା ସମୟରେ, ଏକ 2,000,000-ଧାଡିର ଇନର ଯୋଗଦାନ ଡିଫଲ୍ଟ ଭାବରେ ଇନପୁଟ୍ କ୍ରମରୁ ବାହାରେ ଧାଡି ଫେରାଇଲା ଏବଂ maintain\_order ସେଟ୍ ହୋଇଥିବା ସହିତ କ୍ରମକୁ ରଖିଲା। ମୁକ୍ତଟି ଆଉଟ୍-ଅଫ୍-କୋର ସ୍ପିଲିଂ ମଧ୍ୟ ଚାଲୁ କରେ ଏବଂ ବେଞ୍ଚମାର୍କ ଦାବିଗୁଡ଼ିକୁ ଭେଣ୍ଡରର ନିଜର କରେ।

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

## ଏହି ଭିଡିଓରେ କ'ଣ ଅଛି

- ଏକ lazy କ୍ୱେରୀରେ collect() ଡାକିବା ବର୍ତ୍ତମାନ ଡିଫଲ୍ଟ ଭାବରେ ଷ୍ଟ୍ରିମିଂ ଇଞ୍ଜିନ୍ ବ୍ୟବହାର କରେ, ଯାହା join, group\_by ଏବଂ unpivot ପାଇଁ ଧାଡି କ୍ରମର ଗ୍ୟାରେଣ୍ଟି ଦିଏ ନାହିଁ।
- ମାଇଗ୍ରେସନ ଗାଇଡ୍ କୁହେ ଯେ କ୍ରମଟି ଆଉ 2.0 ପୂର୍ବର କ୍ରମ ନୁହେଁ ଏବଂ ଗ୍ୟାରେଣ୍ଟିଡ୍ ନୁହେଁ; ଯଦି ଆପଣ ଏହା ଉପରେ ନିର୍ଭର କରନ୍ତି ତେବେ ଏକ ସ୍ପଷ୍ଟ sort ସୁପାରିଶ କରେ।
- ଆମର ଚାଲୁଥିବା ସମୟରେ, ଏକ ଡିଫଲ୍ଟ ଇନର ଯୋଗଦାନ ଇନପୁଟ୍ କ୍ରମ False ଫେରାଇଲା; ଯୋଗଦାନ ଉପରେ maintain\_order="left\_right" True ଫେରାଇଲା। ଗୋଟିଏ ମେସିନ୍, ଗୋଟିଏ ଚାଲୁଥିବା, ଗୋଟିଏ ଯୋଗଦାନ ଆକାର।
- ଆଉଟ୍-ଅଫ୍-କୋର ସ୍ପିଲିଂ ଡିଫଲ୍ଟ ଭାବରେ ଚାଲୁ ହୋଇଛି: ଏହା RAM ର ପ୍ରାୟ 80% ରୁ ଆରମ୍ଭ ହୁଏ, 64 GB ଡିଫଲ୍ଟ ଡିସ୍କ ବଜେଟ୍ ସହିତ। ଆଉଟ୍-ଅଫ୍-କୋର join ଏବଂ group\_by ରୋଡମ୍ୟାପରେ ଅଛି।
- collect\_schema() କୌଣସି ଡାଟା ପଢିବା ପୂର୍ବରୁ ଏକ ହଜିଯାଇଥିବା କଲମ୍ ଧରେ, କିନ୍ତୁ ଗୋଟିଏ ମୂଲ୍ୟରେ ବିଫଳ ହେଉଥିବା ଏକ କାଷ୍ଟ କେବଳ collect() ରେ ବିଫଳ ହୁଏ।
- TPC-H ଏବଂ TPC-DS ତୁଳନା ହେଉଛି ଭେଣ୍ଡରର ନିଜସ୍ୱ ଡେରିଭ୍ଡ ଡାଟା ଉପରେ ଚାଲୁଥିବା, ଏବଂ ଏହାର ଫୁଟନୋଟ୍ କୁହେ ଯେ ଫଳାଫଳଗୁଡ଼ିକ ଅଫିସିଆଲ୍ ବେଞ୍ଚମାର୍କ ସହିତ ତୁଳନାଯୋଗ୍ୟ ନୁହେଁ।

## ଅଧ୍ୟାୟଗୁଡ଼ିକ

- 0:00 ଡିଫଲ୍ଟ କ୍ରମ କାହିଁକି ବଦଳିଲା?
- 0:56 ମାଇଗ୍ରେସନ ଗାଇଡ୍ କ'ଣ ପ୍ରତିଜ୍ଞା କରେ?
- 1:17 ବେଞ୍ଚମାର୍କ ଏକ ଉଚିତ ଲଢେଇ କି?
- 1:41 ଆମେ ଏହାକୁ ଚଲାଇଲେ କ'ଣ ଦେଖୁ?
- 1:56 କଠୋର ମାନେ ଶୀଘ୍ର କି?
- 2:07 ମୁଁ ପୁରୁଣା କ୍ରମ କିପରି ଫେରାଇ ଆଣିବି?
- 2:20 ରାୟ କ'ଣ?

## ଅନୁବାଦିତ ଟ୍ରାନ୍ସକ୍ରିପ୍ଟ

ମୂଳ ଇଂରାଜୀ ବର୍ଣ୍ଣନାରୁ ଅନୁବାଦିତ। ଉପଲବ୍ଧ ଅଡିଓ ଏବଂ କ୍ୟାପ୍ସନ୍ଗୁଡ଼ିକ YouTube ଦ୍ୱାରା ନିୟନ୍ତ୍ରିତ।

### ଡିଫଲ୍ଟ କ୍ରମ କାହିଁକି ବଦଳିଲା?

0:00 ଆପଣ ଭାବନ୍ତି ଯେ ଏକ ଯୋଗଦାନ ଆପଣଙ୍କ ଧାଡିଗୁଡ଼ିକୁ ଆପଣ ଲେଖିଥିବା କ୍ରମରେ ଫେରାଇ ଦିଏ। Polars 2.0 ଡିଫଲ୍ଟ ଭାବରେ ସେହି ପ୍ରତିଶ୍ରୁତି ଦେବା ବନ୍ଦ କରିଦେଲା, ଉଦ୍ଦେଶ୍ୟମୂଳକ ଭାବରେ। ଏହି ଭିଡିଓରେ: ଡିଫଲ୍ଟ କାହିଁକି ବଦଳିଲା? ଏହା କ'ଣ ଆଣିଲା? ଏବଂ ଆପଣଙ୍କର କେଉଁ ସ୍କ୍ରିପ୍ଟ ପ୍ରଥମେ ଭାଙ୍ଗିବ? ଏହା ହେଉଛି The Daily Diff, ଢାଙ୍କୁଣୀ ତଳେ। Polars ହେଉଛି ଏକ ଓପନ୍-ସୋର୍ସ ଡାଟାଫ୍ରେମ୍ ଲାଇବ୍ରେରୀ: ଏକ ଟେବୁଲ୍ ଇଞ୍ଜିନ୍ ଯାହାକୁ ଆପଣ ପାଇଥନ୍‌ରୁ ଡାକନ୍ତି,

0:20 ଏହାର ମୂଳ Rust ରେ ଲେଖାଯାଇଛି। ଏହା MIT ଲାଇସେନ୍ସ ଅଧୀନରେ ମାଗଣା, ଏବଂ ଆପଣ ଏହାକୁ pip install polars ସହିତ ଇନଷ୍ଟଲ୍ କରନ୍ତି। ପ୍ରଥମେ ଗୋଟିଏ ବିବରଣୀ। ପୁରୁଣା କ୍ରମ ଫେରାଇ ଆଣୁଥିବା ସୁଇଚ୍ ଯୋଗଦାନରେ ହିଁ ଏକ ଆର୍ଗୁମେଣ୍ଟ। ମୁଁ ଶେଷରେ ଏହାକୁ ଫେରିବି। 2.0 ରୁ, collect ଡିଫଲ୍ଟ ଭାବରେ ଷ୍ଟ୍ରିମିଂ ଇଞ୍ଜିନ୍ ଚଲାଏ। ଷ୍ଟ୍ରିମିଂ କ୍ୱେରୀକୁ ଖଣ୍ଡଗୁଡ଼ିକରେ ବିଭକ୍ତ କରେ ଯାହା ସମାନ୍ତରାଳ ଭାବରେ ଚାଲେ, ଏବଂ ଖଣ୍ଡଗୁଡ଼ିକ ଯେତେବେଳେ ସେଗୁଡ଼ିକ ଶେଷ ହୁଅନ୍ତି, ସେତେବେଳେ ଶେଷ ହୁଅନ୍ତି।

0:42 join, group by ଏବଂ unpivot ପାଇଁ, ମୁକ୍ତଟି ଏକ କ୍ରମର ପ୍ରତିଶ୍ରୁତି ଦିଏ ନାହିଁ। କିଏ ପ୍ରଥମେ ଆଘାତ ପାଇବ? ଯିଏ ଆଉଟପୁଟ୍ କୁ ଏକ ସେଭ୍ ହୋଇଥିବା ଫାଇଲ୍ ସହିତ ତୁଳନା କରେ, ଧାଡିକୁ ଧାଡି। ସେହି ପରୀକ୍ଷା ଆପଣଙ୍କ ଲାପଟପ୍ ରେ ପାସ୍ କରିପାରେ ଏବଂ ଏକ ଭିନ୍ନ ମେସିନ୍ ରେ ଫେଲ୍ ହୋଇପାରେ। ପରେ, ମାଇଗ୍ରେସନ ଗାଇଡ୍।

### ମାଇଗ୍ରେସନ ଗାଇଡ୍ କ'ଣ ପ୍ରତିଜ୍ଞା କରେ?

0:57 ଏହା କୁହେ ଯେ ଉପରୋକ୍ତ ସଠିକ୍ ଧାଡି କ୍ରମ ଗ୍ୟାରେଣ୍ଟିଡ୍ ନୁହେଁ। ତେଣୁ ଯଦି ଆପଣ କ୍ରମ ଉପରେ ନିର୍ଭର କରନ୍ତି, ସ୍ପଷ୍ଟ ଭାବରେ sort କରନ୍ତୁ। ଆଉଟ୍-ଅଫ୍-କୋର ମଧ୍ୟ ଡିଫଲ୍ଟ ଭାବରେ ଚାଲୁ ହୋଇଛି। ଏହା RAM ର ପ୍ରାୟ ଅଶୀ ପ୍ରତିଶତରେ ଡିସ୍କକୁ ସ୍ପିଲ୍ କରିବା ଆରମ୍ଭ କରେ, ଚଉଷଠି ଗିଗାବାଇଟ୍ ବଜେଟ୍ ସହିତ। Sort, window functions ଏବଂ ଅନେକ ଏକ୍ସପ୍ରେସନ୍ ବର୍ତ୍ତମାନ ସ୍ପିଲ୍ କରିପାରିବେ। Joins ଏବଂ group-bys ଆସୁଛନ୍ତି।

### ବେଞ୍ଚମାର୍କ ଏକ ଉଚିତ ଲଢେଇ କି?

1:17 Polars କୁହେ ଯେ ଏହା TPC-H ଏବଂ TPC-DS ରେ DataFusion ଏବଂ DuckDB କୁ ହରାଏ। ବେଞ୍ଚମାର୍କଗୁଡ଼ିକ। ସଂଖ୍ୟାଗୁଡ଼ିକ ସେମାନଙ୍କର ନିଜସ୍ୱ ଚାଲୁଥିବା, ଡେରିଭ୍ଡ ଡାଟା ଉପରେ ଆସିଛି, ଏବଂ ସେମାନଙ୍କର ଫୁଟନୋଟ୍ କୁହେ ଯେ ସେଗୁଡ଼ିକ ଅଫିସିଆଲ୍ ଫଳାଫଳ ସହିତ ତୁଳନାଯୋଗ୍ୟ ନୁହେଁ। ସେମାନଙ୍କର ନିଜସ୍ୱ ସଂଖ୍ୟା କୁହେ ଯେ Polars ପ୍ରାୟ ତିନି ଦଶମିକ ଆଠ ଗୁଣ ଶୀଘ୍ର ହୁଏ। ଷୋହଳ କୋରରୁ ଏକ ଶହ ନବେ-ଦୁଇ, TPC-H ଉପରେ। ସେମାନେ ଏହା ମଧ୍ୟ କୁହନ୍ତି ଯେ ବଡ ମେସିନ୍ ର ଅତିରିକ୍ତ ଥ୍ରେଡ୍ ଛୋଟ କ୍ୱେରୀଗୁଡ଼ିକୁ ଧୀମା କରେ।

### ଆମେ ଏହାକୁ ଚଲାଇଲେ କ'ଣ ଦେଖୁ?

1:41 ଆମେ Polars 2.0.0 ରେ ସମାନ ଯୋଗଦାନ ଦୁଇଥର ଚଳାଇଲୁ। ଡିଫଲ୍ଟ ରନ୍ ଧାଡିଗୁଡ଼ିକୁ ସଫଲ୍ କରେ। ଫ୍ଲାଗ୍ ସହିତ, ଇନପୁଟ୍ କ୍ରମ ବଞ୍ଚିଯାଏ। ଯୋଗଦାନଗୁଡ଼ିକୁ ଖୋଜ ଯାହା ଏକ ପରୀକ୍ଷାକୁ ଖାଇବାକୁ ଦିଏ। ଏହା ପରେ ଏକ sort ନଥିବା ଯେକୌଣସି ଯୋଗଦାନ ହେଉଛି ଏକ ଧାଡି କ୍ରମ ନିଷ୍ପତ୍ତି ଯାହା ଆପଣ କେବେ କରିନାହାନ୍ତି। Polars 2.0 ପ୍ରକାରଗୁଡ଼ିକ ବିଷୟରେ ଅଧିକ କଠୋର।

### କଠୋର ମାନେ ଶୀଘ୍ର କି?

1:58 ସ୍କିମା ଯାଞ୍ଚ କୌଣସି ଡାଟା ପଢିବା ପୂର୍ବରୁ ଏକ ହଜିଯାଇଥିବା କଲମ୍ ଧରେ। ଏହା ଗୋଟିଏ ଧାଡିରେ ବିଫଳ ହେଉଥିବା ଏକ କାଷ୍ଟକୁ ଧରିପାରିବ ନାହିଁ, କାରଣ ସେହି ତ୍ରୁଟି ଅପେକ୍ଷା କରେ। ଡାଟା। ବର୍ତ୍ତମାନ ମୁଁ ଖୋଲିଥିବା ଲୁପ୍।

### ମୁଁ ପୁରୁଣା କ୍ରମ କିପରି ଫେରାଇ ଆଣିବି?

2:08 ସୁଇଚ୍ ଯୋଗଦାନ ଉପରେ ବଞ୍ଚି ରହିଛି। ଯୋଗଦାନ ଉପରେ maintain order ସେଟ୍ କରନ୍ତୁ, କିମ୍ବା ଏହା ପରେ ଏକ sort ଯୋଡନ୍ତୁ। ଗାଇଡ୍ sort ସୁପାରିଶ କରେ। ଯୋଗଦାନ ଫ୍ଲାଗ୍ ଆମର ଚାଲୁଥିବା ସମୟରେ କ୍ରମ ରଖିଲା, ବାମ ପାର୍ଶ୍ୱର କ୍ରମ ବାମ ଭାବରେ ରଖାଯାଇଥିଲା। ଡାହାଣ। ରାୟ, ଢାଙ୍କୁଣୀ ତଳେ: NEEDS REVIEW।

### ରାୟ କ'ଣ?

2:22 ଅପଗ୍ରେଡ୍ କରିବା ପୂର୍ବରୁ ମୁଁ ପ୍ରତ୍ୟେକ ଯୋଗଦାନକୁ ସମୀକ୍ଷା କରିବି। ଏହା ବିଷୟରେ ଏକ ପ୍ରଶ୍ନ ଅଛି କି? ଏହାକୁ କମେଣ୍ଟରେ ରଖନ୍ତୁ। ଏବଂ ତାହା ଆଜି ପାଇଁ diff। ମୁଁ Axrisi ରୁ ନିକୋ। ଦାୟିତ୍ୱର ସହିତ ମିଶାନ୍ତୁ।

## ଉତ୍ସଗୁଡ଼ିକ

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