Polars 2.0: ហេតុអ្វីបានជា joins លែងរក្សាលំដាប់ជួររបស់វា
Polars 2.0 ដំណើរការ collect នៅលើ streaming engine ដោយលំនាំដើម។
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 និងធ្វើឱ្យការអះអាងលទ្ធផលតេស្តជាកម្មសិទ្ធិរបស់អ្នកលក់ផ្ទាល់។
អានបោះពុម្ពជាលាយលក្ខណ៍អក្សរ (អង់គ្លេស) ↗
អ្វីដែលវីដេអូនេះគ្របដណ្ដប់
- ការហៅ 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 គឺជាការដំណើរការផ្ទាល់របស់អ្នកលក់លើទិន្នន័យដែលបានមកពី ហើយកំណត់ចំណាំរបស់វាបាននិយាយថាលទ្ធផលមិនអាចប្រៀបធៀបទៅនឹងលទ្ធផលតេស្តផ្លូវការបានទេ។
សំណួរ និងចម្លើយ
ហេតុអ្វីបានជាការភ្ជាប់ Polars 2.0 លែងរក្សាជួរដេកតាមលំដាប់លំដោយបញ្ចូលរបស់ពួកគេ?
ការហៅ collect លើសំណួរខ្ជិលឥឡូវនេះប្រើម៉ាស៊ីនស្ទ្រីមតាមលំនាំដើម។ ការស្ទ្រីមបំបែកសំណួរទៅជាបំណែកដែលដំណើរការស្របគ្នា ហើយបំណែកបញ្ចប់នៅពេលដែលវាបញ្ចប់។ សម្រាប់ការភ្ជាប់ (join), ក្រុមតាម (group_by) និងបំបែក (unpivot) ការចេញផ្សាយនេះមិនសន្យាពីលំដាប់ជួរដេកលទ្ធផលទេ។ ការធ្វើតេស្តដែលប្រៀបធៀបលទ្ធផលទៅនឹងឯកសារដែលបានរក្សាទុកជាជួរដេក គឺជាការធ្វើតេស្តដំបូងដែលទំនងជានឹងខូច។
តើខ្ញុំទទួលបានលំដាប់ជួរដេកចាស់មកវិញដោយរបៀបណា បន្ទាប់ពីដំឡើងកំណែទៅ Polars 2.0?
បន្ថែមការតម្រៀបជាក់លាក់បន្ទាប់ពីការភ្ជាប់ ដែលជាអ្វីដែលការណែនាំអំពីការធ្វើចំណាកស្រុកបានណែនាំ ឬកំណត់អាគុយម៉ង់ maintain_order លើការភ្ជាប់។ នៅក្នុងការដំណើរការនៃវគ្គលើ Polars 2.0.0 ការភ្ជាប់ខាងក្នុងលំនាំដើមបានត្រឡប់ជួរដេកចេញពីលំដាប់បញ្ចូល ខណៈពេលដែល maintain_order កំណត់ទៅ left_right រក្សាលំដាប់។ នោះជាម៉ាស៊ីនមួយ ការដំណើរការមួយ និងទម្រង់ការភ្ជាប់មួយ។
តើ Polars 2.0 អាចដំណើរការទិន្នន័យធំជាងអង្គចងចាំបានទេ?
មួយផ្នែក។ ការកំពប់ក្រៅស្នូល (Out-of-core spilling) ត្រូវបានបើកតាមលំនាំដើម ដោយចាប់ផ្តើមនៅប្រហែល 80% នៃ RAM ជាមួយនឹងថវិកាថាសលំនាំដើម 64 GB។ ការតម្រៀប (Sort) អនុគមន៍បង្អួច (window functions) និងកន្សោមជាច្រើនអាចកំពប់បានឥឡូវនេះ។ ការភ្ជាប់ក្រៅស្នូល (Out-of-core joins) និងក្រុមតាម (group-bys) ស្ថិតនៅលើផែនទីបង្ហាញផ្លូវ ដូច្នេះប្រតិបត្តិការទាំងនោះមិនទាន់កំពប់នៅឡើយទេ។
តើខ្ញុំអាចជឿទុកចិត្តលើការប្រៀបធៀបស្តង់ដារ Polars 2.0 ជាមួយ DuckDB និង DataFusion បានទេ?
ចាត់ទុកវាជាការអះអាងផ្ទាល់របស់ក្រុមហ៊ុនលក់។ Polars និយាយថាវាឈ្នះ DataFusion និង DuckDB លើ TPC-H និង TPC-DS ប៉ុន្តែលេខទាំងនោះបានមកពីការដំណើរការផ្ទាល់របស់វាលើទិន្នន័យដែលបានមកពី ហើយកំណត់សម្គាល់របស់វាបាននិយាយថាលទ្ធផលមិនអាចប្រៀបធៀបទៅនឹងស្តង់ដារផ្លូវការបានទេ។ Polars ក៏បាននិយាយផងដែរថា ខ្សែស្រឡាយបន្ថែមរបស់ម៉ាស៊ីនធំធ្វើឱ្យសំណួរតូចៗយឺត។
តើវាមានសុវត្ថិភាពទេក្នុងការដំឡើងកំណែបំពង់បង្ហូរ Polars ដែលមានស្រាប់ទៅកំណែ 2.0?
ការវិនិច្ឆ័យរបស់ The Daily Diff គឺ NEEDS REVIEW។ វគ្គនេះនឹងពិនិត្យមើលរាល់ការភ្ជាប់ទាំងអស់មុនពេលដំឡើងកំណែ ពីព្រោះការភ្ជាប់ណាមួយដែលគ្មានការតម្រៀបបន្ទាប់ពីវាគឺជាការសម្រេចចិត្តលំដាប់ជួរដេកដែលមិនធ្លាប់បានធ្វើ។ ការវាយអក្សរតឹងរ៉ឹងជួយបន្តិច ដោយសារតែការត្រួតពិនិត្យគ្រោងការណ៍ចាប់ជួរឈរដែលបាត់មុនពេលទិន្នន័យត្រូវបានអាន ប៉ុន្តែការបោះដែលបរាជ័យលើជួរដេកមួយនឹងបរាជ័យនៅពេលប្រមូលប៉ុណ្ណោះ។
កំណត់ត្រាដែលបានបកប្រែ
បកប្រែចេញពីការនិទានដើមជាភាសាអង់គ្លេស។ សំឡេង និងចំណងជើងរងដែលមានគឺស្ថិតនៅក្រោមការគ្រប់គ្រងរបស់ 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.0Polars (pola.rs)
- Polars 2.0 upgrade guidePolars documentation
- Polars homepagePolars (pola.rs)
- polars-2.0-benchmark repositoryPolars on GitHub
- Release of Polars 2.0 (Hacker News discussion)Hacker News



