# Polars 2.0: ហេតុអ្វីបានជា joins លែងរក្សា​លំដាប់​ជួររបស់វា

Published: 2026-10-08

Polars 2.0 ដំណើរការ collect នៅលើ streaming engine ដោយលំនាំដើម។ សម្រាប់ join, group\_by និង unpivot ការចេញផ្សាយលែងធានាការបញ្ចូលលំដាប់ជួរដេកទៀតទេ លុះត្រាតែអ្នកកំណត់ maintain\_order ឬតម្រៀបដោយផ្ទាល់។ នៅក្នុងការដំណើរការរបស់យើងនៅលើ polars 2.0.0 ការបញ្ចូលគ្នាផ្ទៃក្នុង 2,000,000-ជួរ បានប្រគល់ជួរដេកចេញពីលំដាប់បញ្ចូលដោយលំនាំដើម ហើយរក្សាលំដាប់ដោយកំណត់ maintain\_order។ ការចេញផ្សាយនេះក៏បើក out-of-core spilling និងធ្វើឱ្យការអះអាងលទ្ធផលតេស្តជាកម្មសិទ្ធិរបស់អ្នកលក់ផ្ទាល់។

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

## អ្វីដែលវីដេអូនេះគ្របដណ្ដប់

- ការហៅ collect() លើ lazy query ឥឡូវនេះប្រើ streaming engine ដោយលំនាំដើម ដែលមិនធានាលំដាប់ជួរដេកសម្រាប់ join, group\_by និង unpivot។
- ការណែនាំអំពីការធ្វើចំណាកស្រុកបាននិយាយថាលំដាប់លែងជាលំដាប់មុន 2.0 ហើយមិនត្រូវបានធានាទេ។ វាណែនាំឱ្យតម្រៀបដោយផ្ទាល់ប្រសិនបើអ្នកពឹងផ្អែកលើវា។
- នៅក្នុងការដំណើរការរបស់យើង ការបញ្ចូលគ្នាផ្ទៃក្នុងតាមលំនាំដើមបានប្រគល់លំដាប់បញ្ចូល False; maintain\_order="left\_right" នៅលើការបញ្ចូលគ្នាបានប្រគល់ True។ ម៉ាស៊ីនមួយ ការដំណើរការមួយ ទម្រង់បញ្ចូលគ្នា واحد។
- Out-of-core spilling ត្រូវបានបើកដោយលំនាំដើម៖ វាចាប់ផ្តើមនៅប្រហែល 80% នៃ RAM ជាមួយនឹងថវិកាឌីសលំនាំដើម 64 GB។ Out-of-core join និង group\_by ស្ថិតនៅលើផែនទីបង្ហាញផ្លូវ។
- collect\_schema() ចាប់យកជួរឈរដែលបាត់មុនពេលទិន្នន័យណាមួយត្រូវបានអាន ប៉ុន្តែការបំប្លែងដែលបរាជ័យលើតម្លៃមួយបរាជ័យតែនៅ collect() ប៉ុណ្ណោះ។
- ការប្រៀបធៀប TPC-H និង TPC-DS គឺជាការដំណើរការផ្ទាល់របស់អ្នកលក់លើទិន្នន័យដែលបានមកពី ហើយកំណត់ចំណាំរបស់វាបាននិយាយថាលទ្ធផលមិនអាចប្រៀបធៀបទៅនឹងលទ្ធផលតេស្តផ្លូវការបានទេ។

## ជំពូក

- 0:00 ហេតុអ្វីបានជាលំដាប់លំនាំដើមផ្លាស់ប្តូរ?
- 0:56 តើការណែនាំអំពីការធ្វើចំណាកស្រុកបានសន្យាអ្វីខ្លះ?
- 1:17 តើលទ្ធផលតេស្តនេះសមរម្យដែរឬទេ?
- 1:41 តើយើងឃើញអ្វីខ្លះនៅពេលយើងដំណើរការវា?
- 1:56 តើ Stricter មានន័យថាលឿនជាងនេះទេ?
- 2:07 តើខ្ញុំអាចទទួលបានលំដាប់ចាស់មកវិញដោយរបៀបណា?
- 2:20 តើអ្វីទៅជាការវិនិច្ឆ័យ?

## កំណត់ត្រាដែលបានបកប្រែ

បកប្រែចេញពីការនិទានដើមជាភាសាអង់គ្លេស។ សំឡេង និងចំណងជើងរងដែលមានគឺស្ថិតនៅក្រោមការគ្រប់គ្រងរបស់ YouTube។

### ហេតុអ្វីបានជាលំដាប់លំនាំដើមផ្លាស់ប្តូរ?

0:00 អ្នកគិតថាការបញ្ចូលគ្នាប្រគល់ជួរដេករបស់អ្នកមកវិញតាមលំដាប់ដែលអ្នកបានសរសេរវា។ Polars 2.0 បានឈប់សន្យាដូច្នោះ ដោយលំនាំដើម ដោយចេតនា។ នៅក្នុងវីដេអូនេះ៖ ហេតុអ្វីបានជាលំនាំដើមផ្លាស់ប្តូរ? តើវាទទួលបានអ្វីខ្លះ? ហើយតើសំណុំអត្ថបទរបស់អ្នកមួយណាដែលខូចមុនគេ? នេះគឺជា The Daily Diff, នៅក្រោមក្រណាត់។ Polars គឺជាបណ្ណាល័យ DataFrame ប្រភពបើកចំហរ៖ ម៉ាស៊ីនតារាងដែលអ្នកហៅពី Python,

0:20 ជាមួយនឹងស្នូលរបស់វាសរសេរជា Rust។ វាឥតគិតថ្លៃក្រោមអាជ្ញាប័ណ្ណ MIT ហើយអ្នកដំឡើងវាជាមួយ pip install polars។ លម្អិតមួយមុនគេ។ កុងតាក់ដែលនាំលំដាប់ចាស់មកវិញគឺជាអាគុយម៉ង់សម្រាប់ join ខ្លួនវាផ្ទាល់។ ខ្ញុំនឹងត្រលប់មកវាវិញនៅទីបញ្ចប់។ ចាប់តាំងពី 2.0 មក collect ដំណើរការ streaming engine ដោយលំនាំដើម។ Streaming បំបែក query ជាបំណែកៗដែលដំណើរការស្របគ្នា, ហើយបំណែកៗបញ្ចប់នៅពេលដែលវាបញ្ចប់។

0:42 សម្រាប់ join, group by និង unpivot ការចេញផ្សាយនេះមិនសន្យាលំដាប់ទេ។ តើអ្នកណាមិនទាន់ត្រូវបានប៉ះពាល់? អ្នកណាក៏ដោយដែលប្រៀបធៀបលទ្ធផលទៅនឹងឯកសារដែលបានរក្សាទុក ជួរដេកដោយជួរដេក។ ការសាកល្បងនោះអាចឆ្លងកាត់នៅលើកុំព្យូទ័រយួរដៃរបស់អ្នក ហើយបរាជ័យនៅលើម៉ាស៊ីនផ្សេងគ្នា។ បន្ទាប់មក ការណែនាំអំពីការធ្វើចំណាកស្រុក។

### តើការណែនាំអំពីការធ្វើចំណាកស្រុកបានសន្យាអ្វីខ្លះ?

0:57 វាបាននិយាយថាលំដាប់ជួរដេកពិតប្រាកដដែលបានបង្ហាញខាងលើមិនត្រូវបានធានាទេ។ ដូច្នេះប្រសិនបើអ្នកពឹងផ្អែកលើលំដាប់ សូមតម្រៀបដោយផ្ទាល់។ Out-of-core ត្រូវបានបើកដោយលំនាំដើមផងដែរ។ វាចាប់ផ្តើម spilling ទៅកាន់ថាសនៅប្រហែល 80 ភាគរយនៃ RAM, ជាមួយនឹងថវិកា 64 ជីហ្គាបៃ។ Sort, window functions និងកន្សោមជាច្រើនអាច spill ឥឡូវនេះ។ Joins និង group-bys កំពុងមក។

### តើលទ្ធផលតេស្តនេះសមរម្យដែរឬទេ?

1:17 Polars និយាយថាវាឈ្នះ DataFusion និង DuckDB នៅលើ TPC-H និង TPC-DS លទ្ធផលតេស្ត។ លេខទាំងនេះមកពីការដំណើរការផ្ទាល់របស់ពួកគេ លើទិន្នន័យដែលបានមកពី, ហើយកំណត់ចំណាំរបស់ពួកគេបាននិយាយថាពួកវាមិនអាចប្រៀបធៀបទៅនឹងលទ្ធផលផ្លូវការបានទេ។ លេខផ្ទាល់របស់ពួកគេបាននិយាយថា Polars កាន់តែលឿនប្រហែល 3.8 ដងពី ដប់ប្រាំមួយ cores ទៅមួយរយកៅសិបពីរ នៅលើ TPC-H។ ពួកគេក៏បាននិយាយថា threads បន្ថែមរបស់ម៉ាស៊ីនធំធ្វើឱ្យ queries តូចៗយឺត។

### តើយើងឃើញអ្វីខ្លះនៅពេលយើងដំណើរការវា?

1:41 យើងបានដំណើរការ join ដូចគ្នាពីរដងនៅលើ Polars 2.0.0។ ការដំណើរការលំនាំដើមបានផ្លាស់ប្តូរជួរដេក។ ជាមួយនឹងទង់ លំដាប់បញ្ចូលនៅតែរក្សាបាន។ ស្វែងរក joins ដែលផ្តល់ទិន្នន័យដល់ការសាកល្បង។ Join ណាមួយដែលគ្មាន sort បន្ទាប់ពីវាគឺជាការសម្រេចចិត្តលំដាប់ជួរដេកដែលអ្នកមិនដែលបានធ្វើ។ Polars 2.0 កាន់តែតឹងរ៉ឹងអំពីប្រភេទ។

### តើ Stricter មានន័យថាលឿនជាងនេះទេ?

1:58 ការត្រួតពិនិត្យ schema ចាប់យកជួរឈរដែលបាត់មុនពេលទិន្នន័យណាមួយត្រូវបានអាន។ វាមិនអាចចាប់យក cast ដែលបរាជ័យលើជួរដេកមួយបានទេ ពីព្រោះកំហុសនោះរង់ចាំសម្រាប់ ទិន្នន័យ។ ឥឡូវនេះរង្វិលជុំដែលខ្ញុំបានបើក។

### តើខ្ញុំអាចទទួលបានលំដាប់ចាស់មកវិញដោយរបៀបណា?

2:08 កុងតាក់ស្ថិតនៅលើ join។ កំណត់ maintain order លើ join ឬបន្ថែម sort បន្ទាប់ពីវា។ ការណែនាំណែនាំ sort។ ទង់ join បានរក្សាលំដាប់នៅក្នុងការដំណើរការរបស់យើង ជាមួយនឹងលំដាប់ខាងឆ្វេងត្រូវបានរក្សាជា ឆ្វេង ស្ដាំ។ ការវិនិច្ឆ័យ នៅក្រោមក្រណាត់៖ NEEDS REVIEW។

### តើអ្វីទៅជាការវិនិច្ឆ័យ?

2:22 ខ្ញុំនឹងពិនិត្យឡើងវិញនូវ join ទាំងអស់មុនពេលដំឡើងកំណែ។ មានសំណួរអំពីនេះទេ? ដាក់វានៅក្នុងមតិយោបល់។ ហើយនោះគឺជាភាពខុសគ្នាសម្រាប់ថ្ងៃនេះ។ ខ្ញុំឈ្មោះ Niko មកពី 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