పోలార్స్ 2.0: జాయిన్లు తమ వరుస క్రమాన్ని ఎందుకు ఉంచవు
పోలార్స్ 2.0 డిఫాల్ట్గా స్ట్రీమింగ్ ఇంజిన్పై కలెక్ట్ (collect)ను అమలు చేస్తుంది.
పోలార్స్ 2.0 డిఫాల్ట్గా స్ట్రీమింగ్ ఇంజిన్పై కలెక్ట్ (collect)ను అమలు చేస్తుంది. జాయిన్ (join), గ్రూప్_బై (group_by) మరియు అన్-పివోట్ (unpivot) కోసం, మీరు మెయింటైన్_ఆర్డర్ (maintain_order) లేదా సార్ట్ (sort)ను స్పష్టంగా సెట్ చేయకపోతే విడుదల ఇన్పుట్ వరుస క్రమానికి హామీ ఇవ్వదు. మా పోలార్స్ 2.0.0లో, 2,000,000-వరుసల ఇన్నర్ జాయిన్ డిఫాల్ట్గా ఇన్పుట్ ఆర్డర్ వెలుపల వరుసలను తిరిగి ఇచ్చింది మరియు మెయింటైన్_ఆర్డర్ సెట్ చేసినప్పుడు క్రమాన్ని ఉంచింది. ఈ విడుదల అవుట్-ఆఫ్-కోర్ స్పిల్లింగ్ను కూడా ఆన్ చేస్తుంది మరియు బెంచ్మార్క్ క్లెయిమ్లను విక్రేత తన సొంతంగా చేస్తుంది.
వ్రాతపూర్వక సంచికను చదవండి (ఇంగ్లీష్) ↗
ఈ వీడియో ఏమి కవర్ చేస్తుంది
- ఒక లేజీ క్వెరీపై కలెక్ట్()ను పిలవడం ఇప్పుడు డిఫాల్ట్గా స్ట్రీమింగ్ ఇంజిన్ను ఉపయోగిస్తుంది, ఇది జాయిన్, గ్రూప్_బై మరియు అన్-పివోట్ కోసం వరుస క్రమానికి హామీ ఇవ్వదు.
- మైగ్రేషన్ గైడ్ ప్రకారం, ఆర్డర్ ఇకపై ప్రీ-2.0 ఆర్డర్ కాదు మరియు హామీ ఇవ్వబడదు; మీరు దానిపై ఆధారపడితే స్పష్టమైన సార్ట్ను సిఫార్సు చేస్తుంది.
- మా రన్లో, డిఫాల్ట్ ఇన్నర్ జాయిన్ ఇన్పుట్ ఆర్డర్ను ఫాల్స్ అని తిరిగి ఇచ్చింది; జాయిన్పై maintain_order="left_right" ట్రూ అని తిరిగి ఇచ్చింది. ఒక మెషిన్, ఒక రన్, ఒక జాయిన్ షేప్.
- అవుట్-ఆఫ్-కోర్ స్పిల్లింగ్ డిఫాల్ట్గా ఆన్ చేయబడింది: ఇది RAMలో సుమారు 80% వద్ద ప్రారంభమవుతుంది, 64 GB డిఫాల్ట్ డిస్క్ బడ్జెట్తో. అవుట్-ఆఫ్-కోర్ జాయిన్ మరియు గ్రూప్_బై రోడ్మ్యాప్లో ఉన్నాయి.
- collect_schema() ఎటువంటి డేటాను చదవడానికి ముందే తప్పిపోయిన కాలమ్ను పట్టుకుంటుంది, కానీ ఒక విలువపై మాత్రమే విఫలమయ్యే కాస్ట్ collect() వద్ద మాత్రమే విఫలమవుతుంది.
- TPC-H మరియు TPC-DS పోలిక విక్రేత యొక్క సొంత రన్, ఉత్పాదక డేటాపై, మరియు దాని ఫుట్నోట్ ఫలితాలు అధికారిక బెంచ్మార్క్లతో పోల్చదగినవి కాదని పేర్కొంది.
ప్రశ్నలు మరియు సమాధానాలు
పోలార్స్ 2.0 జాయిన్లు వాటి ఇన్పుట్ ఆర్డర్లో వరుసలను ఎందుకు ఉంచడం లేదు?
ఒక లేజీ క్వెరీపై కాల్ చేయగా డిఫాల్ట్గా స్ట్రీమింగ్ ఇంజిన్ను ఉపయోగిస్తుంది. స్ట్రీమింగ్ క్వెరీని సమాంతరంగా నడుస్తున్న చిన్న చిన్న భాగాలుగా విభజిస్తుంది, మరియు ఆ భాగాలు ఎప్పుడు పూర్తయితే అప్పుడు ముగుస్తాయి. జాయిన్, గ్రూప్_బై మరియు అన్పివోట్ కోసం, విడుదల కాబట్టి అవుట్పుట్ వరుస క్రమాన్ని వాగ్దానం చేయదు. అవుట్పుట్ను సేవ్ చేసిన ఫైల్ వరుసగా వరుసగా పోల్చే పరీక్షలు మొదట విఫలమయ్యే అవకాశం ఉంది.
పోలార్స్ 2.0కి అప్గ్రేడ్ చేసిన తర్వాత పాత వరుస క్రమాన్ని తిరిగి ఎలా పొందాలి?
జాయిన్ తర్వాత స్పష్టమైన సార్ట్ను జోడించండి, ఇది వలస మార్గదర్శకంలో సిఫార్సు చేయబడింది, లేదా జాయిన్పై maintain_order ఆర్గ్యుమెంట్ను సెట్ చేయండి. పోలార్స్ 2.0.0లో ఎపిసోడ్ రన్ అయినప్పుడు, ఒక డిఫాల్ట్ ఇన్నర్ జాయిన్ ఇన్పుట్ ఆర్డర్ వెలుపల వరుసలను తిరిగి ఇచ్చింది, అయితే maintain_order left_rightకు సెట్ చేయబడినప్పుడు ఆర్డర్ను ఉంచింది. అది ఒక యంత్రం, ఒక రన్ మరియు ఒక జాయిన్ ఆకృతి.
పోలార్స్ 2.0 మెమరీ కంటే పెద్ద డేటాను ప్రాసెస్ చేయగలదా?
పాక్షికంగా. అవుట్-ఆఫ్-కోర్ స్పిల్లింగ్ డిఫాల్ట్గా ఆన్లో ఉంది, RAMలో సుమారు 80% తో 64 GB డిఫాల్ట్ డిస్క్ బడ్జెట్తో ప్రారంభమవుతుంది. సార్ట్, విండో ఫంక్షన్లు మరియు అనేక వ్యక్తీకరణలు ఇప్పుడు స్పిల్ చేయగలవు. అవుట్-ఆఫ్-కోర్ జాయిన్లు మరియు గ్రూప్-బైలు రోడ్మ్యాప్లో ఉన్నాయి, కాబట్టి ఆ కార్యకలాపాలు ఇంకా స్పిల్ చేయవు.
డక్డిబి మరియు డేటాఫ్యూజన్తో పోలార్స్ 2.0 బెంచ్మార్క్ పోలికలను నేను నమ్మవచ్చా?
వాటిని విక్రేత యొక్క స్వంత వాదనలుగా పరిగణించండి. TPC-H మరియు TPC-DSలో డేటాఫ్యూజన్ మరియు డక్డిబిలను ఓడించిందని పోలార్స్ చెబుతోంది, కానీ ఆ సంఖ్యలు దాని స్వంత రన్ల నుండి ఉత్పన్నమైన డేటాపై వచ్చాయి, మరియు దాని ఫుట్నోట్ ఫలితాలు అధికారిక బెంచ్మార్క్లతో పోల్చదగినవి కాదని చెబుతోంది. పెద్ద యంత్రం యొక్క అదనపు థ్రెడ్లు చిన్న క్వెరీలను నెమ్మదిగా చేస్తాయని కూడా పోలార్స్ చెబుతోంది.
ఇప్పటికే ఉన్న పోలార్స్ పైప్లైన్లను వెర్షన్ 2.0కి అప్గ్రేడ్ చేయడం సురక్షితమేనా?
The Daily Diff యొక్క తీర్పు NEEDS REVIEW. ఎపిసోడ్ అప్గ్రేడ్ చేసే ముందు ప్రతి జాయిన్ను సమీక్షిస్తుంది, ఎందుకంటే దాని తర్వాత సార్ట్ లేని ఏ జాయిన్ అయినా వరుస ఆర్డర్ నిర్ణయం ఎప్పుడూ తీసుకోలేదు. కఠినమైన టైపింగ్ కొద్దిగా సహాయపడుతుంది, ఎందుకంటే స్కీమా తనిఖీ డేటా చదవడానికి ముందే తప్పిపోయిన కాలమ్ను పట్టుకుంటుంది, కానీ ఒక వరుసలో మాత్రమే విఫలమయ్యే క్యాస్ట్ కలెక్ట్ వద్ద మాత్రమే విఫలమవుతుంది.
అనువదించబడిన ట్రాన్స్క్రిప్ట్
అసలైన ఆంగ్ల కథనం నుండి అనువదించబడింది. అందుబాటులో ఉన్న ఆడియో మరియు క్యాప్షన్లు YouTube ద్వారా నియంత్రించబడతాయి.
డిఫాల్ట్ ఆర్డర్ ఎందుకు మారింది?
0:00 మీరు ఒక జాయిన్ మీ వరుసలను మీరు రాసిన క్రమంలోనే తిరిగి ఇస్తుందని అనుకుంటారు. పోలార్స్ 2.0 డిఫాల్ట్గా ఆ హామీని కావాలనే ఆపేసింది. ఈ వీడియోలో: డిఫాల్ట్ ఎందుకు మారింది? అది ఏమి కొనుగోలు చేసింది? మరియు మీ స్క్రిప్ట్లలో ఏది ముందుగా విరిగిపోతుంది? ఇది ది డైలీ డిఫ్, తెర వెనుక. పోలార్స్ ఒక ఓపెన్-సోర్స్ డేటాఫ్రేమ్ లైబ్రరీ: మీరు పైథాన్ నుండి పిలిచే ఒక టేబుల్ ఇంజిన్,
0:20 దాని కోర్ రస్ట్లో వ్రాయబడింది. ఇది MIT లైసెన్స్ కింద ఉచితం, మరియు మీరు దానిని pip install polarsతో ఇన్స్టాల్ చేయవచ్చు. ముందుగా ఒక వివరాలు. పాత ఆర్డర్ను తిరిగి తెచ్చే స్విచ్ జాయిన్కే ఒక ఆర్గ్యుమెంట్. నేను చివరిలో దీనికి తిరిగి వస్తాను. 2.0 నుండి, కలెక్ట్ డిఫాల్ట్గా స్ట్రీమింగ్ ఇంజిన్ను అమలు చేస్తుంది. స్ట్రీమింగ్ క్వెరీని సమాంతరంగా నడిచే ముక్కలుగా విభజిస్తుంది, మరియు ముక్కలు అవి పూర్తయినప్పుడు పూర్తవుతాయి.
0:42 జాయిన్, గ్రూప్ బై మరియు అన్-పివోట్ కోసం, విడుదల ఒక ఆర్డర్కు హామీ ఇవ్వదు. ఎవరు ముందుగా ప్రభావితమవుతారు? సేవ్ చేసిన ఫైల్తో అవుట్పుట్ను వరుసగా పోల్చే ఎవరైనా. ఆ టెస్ట్ మీ ల్యాప్టాప్లో పాస్ కావచ్చు మరియు వేరే మెషీన్లో విఫలం కావచ్చు. తరువాత, మైగ్రేషన్ గైడ్.
మైగ్రేషన్ గైడ్ ఏమి హామీ ఇస్తుంది?
0:57 పైన చూపిన ఖచ్చితమైన వరుస క్రమం హామీ ఇవ్వబడదని అది పేర్కొంది. కాబట్టి మీరు క్రమంపై ఆధారపడితే, స్పష్టంగా క్రమబద్ధీకరించండి. అవుట్-ఆఫ్-కోర్ కూడా డిఫాల్ట్గా ఆన్లో ఉంది. ఇది RAMలో సుమారు ఎనభై శాతం వద్ద డిస్క్కు స్పిల్లింగ్ చేయడం ప్రారంభిస్తుంది, అరవై నాలుగు గిగాబైట్ల బడ్జెట్తో. సార్ట్, విండో ఫంక్షన్లు మరియు అనేక వ్యక్తీకరణలు ఇప్పుడు స్పిల్ చేయగలవు. జాయిన్లు మరియు గ్రూప్-బైలు వస్తున్నాయి.
బెంచ్మార్క్ సరసమైన పోటీనా?
1:17 పోలార్స్ TPC-H మరియు TPC-DS బెంచ్మార్క్లలో డేటాఫ్యూజన్ మరియు డక్డిబిని ఓడిస్తుందని పేర్కొంది. సంఖ్యలు వారి స్వంత రన్ల నుండి వచ్చాయి, ఉత్పాదక డేటాపై, మరియు వారి ఫుట్నోట్ అవి అధికారిక ఫలితాలతో పోల్చదగినవి కాదని పేర్కొంది. వారి స్వంత సంఖ్యల ప్రకారం TPC-Hలో పోలార్స్ పదహారు కోర్ల నుండి నూట తొంభై రెండు వరకు సుమారు మూడు పాయింట్ ఎనిమిది రెట్లు వేగంగా పెరుగుతుంది. పెద్ద మెషిన్ యొక్క అదనపు థ్రెడ్లు చిన్న క్వెరీలను నెమ్మదింపజేస్తాయని కూడా వారు పేర్కొన్నారు. మేము పోలార్స్ 2.0.0లో అదే జాయిన్ను రెండుసార్లు అమలు చేసాము.
మనం దాన్ని అమలు చేసినప్పుడు ఏమి చూస్తాము?
1:41 డిఫాల్ట్ రన్ వరుసలను షఫిల్ చేస్తుంది. ఫ్లాగ్తో, ఇన్పుట్ ఆర్డర్ నిలిచి ఉంటుంది. ఒక టెస్ట్కు ఫీడ్ చేసే జాయిన్లను కనుగొనండి. తర్వాత సార్ట్ లేని ఏ జాయిన్ అయినా మీరు ఎప్పుడూ చేయని వరుస క్రమం నిర్ణయం. పోలార్స్ 2.0 రకాల విషయంలో కఠినంగా ఉంటుంది. స్కీమా చెక్ ఎటువంటి డేటాను చదవడానికి ముందే తప్పిపోయిన కాలమ్ను పట్టుకుంటుంది.
కఠినంగా ఉండటం అంటే ముందుగానేనా?
1:58 ఒక వరుసపై విఫలమయ్యే కాస్ట్ను పట్టుకోలేదు, ఎందుకంటే ఆ లోపం డేటా కోసం వేచి ఉంటుంది. ఇప్పుడు నేను తెరిచిన లూప్. స్విచ్ జాయిన్పై ఉంటుంది.
నేను పాత ఆర్డర్ను ఎలా తిరిగి పొందగలను?
2:08 జాయిన్పై మెయింటైన్ ఆర్డర్ను సెట్ చేయండి, లేదా దాని తర్వాత సార్ట్ను జోడించండి. గైడ్ సార్ట్ను సూచిస్తుంది. మా రన్లో జాయిన్ ఫ్లాగ్ క్రమాన్ని ఉంచింది, ఎడమ వైపు క్రమాన్ని ఎడమ, కుడి అని ఉంచింది. తీర్పు, తెర వెనుక: సమీక్ష అవసరం. అప్గ్రేడ్ చేయడానికి ముందు నేను ప్రతి జాయిన్ను సమీక్షిస్తాను. దీని గురించి మీకు ప్రశ్న ఉందా?
తీర్పు ఏమిటి?
2:22 దాన్ని వ్యాఖ్యలలో ఉంచండి. మరియు అది ఈరోజుకు డిఫ్. నేను ఆక్స్రిసి నుండి నికోని. బాధ్యతాయుతంగా విలీనం చేయండి. నేను ఆక్స్రిసి నుండి నికోని. బాధ్యతాయుతంగా విలీనం చేయండి.
మూలాలు
- 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



