ਪੋਲਰਸ 2.0: ਜੁਆਇਨ ਹੁਣ ਆਪਣੀ ਕਤਾਰ ਕ੍ਰਮ ਨੂੰ ਕਿਉਂ ਨਹੀਂ ਰੱਖਦੇ
ਪੋਲਰਸ 2.0 ਡਿਫੌਲਟ ਰੂਪ ਵਿੱਚ ਇੱਕ ਸਟ੍ਰੀਮਿੰਗ ਇੰਜਣ 'ਤੇ ਕਲੈਕਟ ਚਲਾਉਂਦਾ ਹੈ।
ਪੋਲਰਸ 2.0 ਡਿਫੌਲਟ ਰੂਪ ਵਿੱਚ ਇੱਕ ਸਟ੍ਰੀਮਿੰਗ ਇੰਜਣ 'ਤੇ ਕਲੈਕਟ ਚਲਾਉਂਦਾ ਹੈ। ਜੁਆਇਨ, ਗਰੁੱਪ_ਬਾਈ ਅਤੇ ਅਨਪਿਵਟ ਲਈ, ਰੀਲੀਜ਼ ਹੁਣ ਇਨਪੁਟ ਕਤਾਰ ਕ੍ਰਮ ਦੀ ਗਾਰੰਟੀ ਨਹੀਂ ਦਿੰਦੀ ਜਦੋਂ ਤੱਕ ਤੁਸੀਂ maintain_order ਜਾਂ sort ਨੂੰ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਸੈੱਟ ਨਹੀਂ ਕਰਦੇ। ਸਾਡੇ ਪੋਲਰਸ 2.0.0 'ਤੇ ਚੱਲਣ ਵਿੱਚ, ਇੱਕ 2,000,000-ਕਤਾਰ ਦਾ ਅੰਦਰੂਨੀ ਜੁਆਇਨ ਡਿਫੌਲਟ ਰੂਪ ਵਿੱਚ ਇਨਪੁਟ ਕ੍ਰਮ ਤੋਂ ਬਾਹਰ ਕਤਾਰਾਂ ਵਾਪਸ ਕਰਦਾ ਹੈ ਅਤੇ maintain_order ਸੈੱਟ ਨਾਲ ਕ੍ਰਮ ਨੂੰ ਬਰਕਰਾਰ ਰੱਖਦਾ ਹੈ। ਰੀਲੀਜ਼ ਆਉਟ-ਆਫ-ਕੋਰ ਸਪਿਲਿੰਗ ਨੂੰ ਵੀ ਚਾਲੂ ਕਰਦੀ ਹੈ ਅਤੇ ਬੈਂਚਮਾਰਕ ਦੇ ਦਾਅਵਿਆਂ ਨੂੰ ਵਿਕਰੇਤਾ ਦੇ ਆਪਣੇ ਬਣਾਉਂਦੀ ਹੈ।
ਲਿਖਤੀ ਐਡੀਸ਼ਨ ਪੜ੍ਹੋ (ਅੰਗਰੇਜ਼ੀ) ↗
ਇਹ ਵੀਡੀਓ ਕੀ ਕਵਰ ਕਰਦਾ ਹੈ
- ਇੱਕ ਸੁਸਤ ਪੁੱਛਗਿੱਛ 'ਤੇ collect() ਨੂੰ ਕਾਲ ਕਰਨਾ ਹੁਣ ਡਿਫੌਲਟ ਰੂਪ ਵਿੱਚ ਸਟ੍ਰੀਮਿੰਗ ਇੰਜਣ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਜੋ ਜੁਆਇਨ, ਗਰੁੱਪ_ਬਾਈ ਅਤੇ ਅਨਪਿਵਟ ਲਈ ਕਤਾਰ ਕ੍ਰਮ ਦੀ ਗਾਰੰਟੀ ਨਹੀਂ ਦਿੰਦਾ।
- ਮਾਈਗ੍ਰੇਸ਼ਨ ਗਾਈਡ ਕਹਿੰਦੀ ਹੈ ਕਿ ਕ੍ਰਮ ਹੁਣ ਪ੍ਰੀ-2.0 ਕ੍ਰਮ ਨਹੀਂ ਹੈ ਅਤੇ ਇਸਦੀ ਗਾਰੰਟੀ ਨਹੀਂ ਹੈ; ਇਹ ਇੱਕ ਸਪੱਸ਼ਟ sort ਦੀ ਸਿਫ਼ਾਰਸ਼ ਕਰਦਾ ਹੈ ਜੇਕਰ ਤੁਸੀਂ ਇਸ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹੋ।
- ਸਾਡੇ ਚੱਲਣ ਵਿੱਚ, ਇੱਕ ਡਿਫੌਲਟ ਅੰਦਰੂਨੀ ਜੁਆਇਨ ਨੇ ਇਨਪੁਟ ਕ੍ਰਮ False ਵਾਪਸ ਕੀਤਾ; ਜੁਆਇਨ 'ਤੇ maintain_order="left_right" ਨੇ True ਵਾਪਸ ਕੀਤਾ। ਇੱਕ ਮਸ਼ੀਨ, ਇੱਕ ਚੱਲਣ, ਇੱਕ ਜੁਆਇਨ ਸ਼ੇਪ।
- ਆਉਟ-ਆਫ-ਕੋਰ ਸਪਿਲਿੰਗ ਡਿਫੌਲਟ ਰੂਪ ਵਿੱਚ ਚਾਲੂ ਹੈ: ਇਹ RAM ਦੇ ਲਗਭਗ 80% ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ, ਜਿਸ ਵਿੱਚ 64 GB ਡਿਫੌਲਟ ਡਿਸਕ ਬਜਟ ਹੁੰਦਾ ਹੈ। ਆਉਟ-ਆਫ-ਕੋਰ ਜੁਆਇਨ ਅਤੇ ਗਰੁੱਪ_ਬਾਈ ਰੋਡਮੈਪ 'ਤੇ ਹਨ।
- collect_schema() ਕਿਸੇ ਵੀ ਡਾਟੇ ਨੂੰ ਪੜ੍ਹਨ ਤੋਂ ਪਹਿਲਾਂ ਇੱਕ ਗੁੰਮ ਕਾਲਮ ਨੂੰ ਫੜ ਲੈਂਦਾ ਹੈ, ਪਰ ਇੱਕ ਕਾਸਟ ਜੋ ਸਿਰਫ ਇੱਕ ਮੁੱਲ 'ਤੇ ਅਸਫਲ ਹੁੰਦਾ ਹੈ, ਉਹ ਸਿਰਫ collect() 'ਤੇ ਅਸਫਲ ਹੁੰਦਾ ਹੈ।
- TPC-H ਅਤੇ TPC-DS ਤੁਲਨਾ ਵਿਕਰੇਤਾ ਦੀ ਆਪਣੀ ਪ੍ਰਾਪਤ ਡਾਟੇ 'ਤੇ ਚੱਲਣ ਹੈ, ਅਤੇ ਇਸਦੇ ਫੁਟਨੋਟ ਵਿੱਚ ਕਿਹਾ ਗਿਆ ਹੈ ਕਿ ਨਤੀਜੇ ਅਧਿਕਾਰਤ ਬੈਂਚਮਾਰਕਾਂ ਨਾਲ ਤੁਲਨਾਯੋਗ ਨਹੀਂ ਹਨ।
ਅਨੁਵਾਦਿਤ ਟ੍ਰਾਂਸਕ੍ਰਿਪਟ
ਮੂਲ ਅੰਗਰੇਜ਼ੀ ਬਿਰਤਾਂਤ ਤੋਂ ਅਨੁਵਾਦ ਕੀਤਾ ਗਿਆ। ਉਪਲਬਧ ਆਡੀਓ ਅਤੇ ਕੈਪਸ਼ਨ YouTube ਦੁਆਰਾ ਨਿਯੰਤਰਿਤ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।
ਡਿਫੌਲਟ ਕ੍ਰਮ ਕਿਉਂ ਬਦਲਿਆ?
0:00 ਤੁਸੀਂ ਸੋਚਦੇ ਹੋ ਕਿ ਇੱਕ ਜੁਆਇਨ ਤੁਹਾਡੀਆਂ ਕਤਾਰਾਂ ਨੂੰ ਉਸੇ ਕ੍ਰਮ ਵਿੱਚ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਤੁਸੀਂ ਉਹਨਾਂ ਨੂੰ ਲਿਖਿਆ ਸੀ। ਪੋਲਰਸ 2.0 ਨੇ ਡਿਫੌਲਟ ਰੂਪ ਵਿੱਚ, ਜਾਣਬੁੱਝ ਕੇ, ਉਸ ਵਾਅਦੇ ਨੂੰ ਬੰਦ ਕਰ ਦਿੱਤਾ। ਇਸ ਵੀਡੀਓ ਵਿੱਚ: ਡਿਫੌਲਟ ਕਿਉਂ ਬਦਲਿਆ? ਇਸਨੇ ਕੀ ਖਰੀਦਿਆ? ਅਤੇ ਤੁਹਾਡੀਆਂ ਕਿਹੜੀਆਂ ਸਕ੍ਰਿਪਟਾਂ ਪਹਿਲਾਂ ਟੁੱਟਦੀਆਂ ਹਨ? ਇਹ The Daily Diff ਹੈ, ਪਰਦੇ ਦੇ ਪਿੱਛੇ। ਪੋਲਰਸ ਇੱਕ ਓਪਨ-ਸੋਰਸ ਡੇਟਾਫ੍ਰੇਮ ਲਾਇਬ੍ਰੇਰੀ ਹੈ: ਇੱਕ ਟੇਬਲ ਇੰਜਣ ਜਿਸਨੂੰ ਤੁਸੀਂ ਪਾਈਥਨ ਤੋਂ ਕਾਲ ਕਰਦੇ ਹੋ,
0:20 ਜਿਸਦਾ ਕੋਰ ਰਸਟ ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਹੈ। ਇਹ MIT ਲਾਇਸੈਂਸ ਦੇ ਅਧੀਨ ਮੁਫਤ ਹੈ, ਅਤੇ ਤੁਸੀਂ ਇਸਨੂੰ pip install polars ਨਾਲ ਸਥਾਪਿਤ ਕਰਦੇ ਹੋ। ਪਹਿਲਾਂ ਇੱਕ ਵੇਰਵਾ। ਜੋ ਸਵਿੱਚ ਪੁਰਾਣੇ ਆਰਡਰ ਨੂੰ ਵਾਪਸ ਲਿਆਉਂਦਾ ਹੈ, ਉਹ ਜੁਆਇਨ ਲਈ ਇੱਕ ਆਰਗੂਮੈਂਟ ਹੈ। ਮੈਂ ਇਸ 'ਤੇ ਅੰਤ ਵਿੱਚ ਵਾਪਸ ਆਵਾਂਗਾ। 2.0 ਤੋਂ, collect ਡਿਫੌਲਟ ਰੂਪ ਵਿੱਚ ਸਟ੍ਰੀਮਿੰਗ ਇੰਜਣ ਚਲਾਉਂਦਾ ਹੈ। ਸਟ੍ਰੀਮਿੰਗ ਪੁੱਛਗਿੱਛ ਨੂੰ ਚੰਕਾਂ ਵਿੱਚ ਵੰਡਦੀ ਹੈ ਜੋ ਸਮਾਂਤਰ ਵਿੱਚ ਚੱਲਦੀਆਂ ਹਨ, ਅਤੇ ਚੰਕਾਂ ਉਦੋਂ ਖਤਮ ਹੁੰਦੀਆਂ ਹਨ ਜਦੋਂ ਉਹ ਖਤਮ ਹੁੰਦੀਆਂ ਹਨ।
0:42 ਜੁਆਇਨ, ਗਰੁੱਪ ਬਾਈ ਅਤੇ ਅਨਪਿਵਟ ਲਈ, ਰੀਲੀਜ਼ ਇੱਕ ਕ੍ਰਮ ਦਾ ਵਾਅਦਾ ਨਹੀਂ ਕਰਦੀ। ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਕੌਣ ਮਾਰਿਆ ਜਾਵੇਗਾ? ਜੋ ਵੀ ਆਉਟਪੁੱਟ ਦੀ ਤੁਲਨਾ ਇੱਕ ਸੁਰੱਖਿਅਤ ਕੀਤੀ ਫਾਈਲ ਨਾਲ ਕਰਦਾ ਹੈ, ਕਤਾਰ ਦਰ ਕਤਾਰ। ਉਹ ਟੈਸਟ ਤੁਹਾਡੇ ਲੈਪਟਾਪ 'ਤੇ ਪਾਸ ਹੋ ਸਕਦਾ ਹੈ ਅਤੇ ਕਿਸੇ ਵੱਖਰੀ ਮਸ਼ੀਨ 'ਤੇ ਫੇਲ੍ਹ ਹੋ ਸਕਦਾ ਹੈ। ਅੱਗੇ, ਮਾਈਗ੍ਰੇਸ਼ਨ ਗਾਈਡ।
ਮਾਈਗ੍ਰੇਸ਼ਨ ਗਾਈਡ ਕੀ ਵਾਅਦਾ ਕਰਦੀ ਹੈ?
0:57 ਇਹ ਕਹਿੰਦਾ ਹੈ ਕਿ ਉੱਪਰ ਦਿਖਾਇਆ ਗਿਆ ਸਹੀ ਕਤਾਰ ਕ੍ਰਮ ਦੀ ਗਾਰੰਟੀ ਨਹੀਂ ਹੈ। ਇਸ ਲਈ ਜੇਕਰ ਤੁਸੀਂ ਕ੍ਰਮ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹੋ, ਤਾਂ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ sort ਕਰੋ। ਆਉਟ-ਆਫ-ਕੋਰ ਵੀ ਡਿਫੌਲਟ ਰੂਪ ਵਿੱਚ ਚਾਲੂ ਹੈ। ਇਹ RAM ਦੇ ਲਗਭਗ ਅੱਸੀ ਪ੍ਰਤੀਸ਼ਤ 'ਤੇ ਡਿਸਕ 'ਤੇ ਸਪਿਲ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ, ਸੱਠ-ਚਾਰ ਗੀਗਾਬਾਈਟ ਦੇ ਬਜਟ ਨਾਲ। Sort, window functions ਅਤੇ ਕਈ ਸਮੀਕਰਨ ਹੁਣ ਸਪਿਲ ਕਰ ਸਕਦੇ ਹਨ। Joins ਅਤੇ group-bys ਆ ਰਹੇ ਹਨ।
ਕੀ ਬੈਂਚਮਾਰਕ ਇੱਕ ਨਿਰਪੱਖ ਲੜਾਈ ਹੈ?
1:17 ਪੋਲਰਸ ਕਹਿੰਦਾ ਹੈ ਕਿ ਇਹ TPC-H ਅਤੇ TPC-DS 'ਤੇ DataFusion ਅਤੇ DuckDB ਨੂੰ ਹਰਾਉਂਦਾ ਹੈ ਬੈਂਚਮਾਰਕ। ਨੰਬਰ ਉਹਨਾਂ ਦੇ ਆਪਣੇ ਚੱਲਣ ਤੋਂ ਆਉਂਦੇ ਹਨ, ਪ੍ਰਾਪਤ ਡਾਟੇ 'ਤੇ, ਅਤੇ ਉਹਨਾਂ ਦੇ ਫੁਟਨੋਟ ਵਿੱਚ ਕਿਹਾ ਗਿਆ ਹੈ ਕਿ ਉਹ ਅਧਿਕਾਰਤ ਨਤੀਜਿਆਂ ਨਾਲ ਤੁਲਨਾਯੋਗ ਨਹੀਂ ਹਨ। ਉਹਨਾਂ ਦੇ ਆਪਣੇ ਨੰਬਰ ਕਹਿੰਦੇ ਹਨ ਕਿ ਪੋਲਰਸ TPC-H 'ਤੇ ਸੋਲ੍ਹਾਂ ਕੋਰਾਂ ਤੋਂ ਇੱਕ ਸੌ ਬਾਨਵੇ ਤੱਕ ਲਗਭਗ ਤਿੰਨ ਪੁਆਇੰਟ ਅੱਠ ਗੁਣਾ ਤੇਜ਼ ਹੁੰਦਾ ਹੈ। ਸੋਲ੍ਹਾਂ ਕੋਰਾਂ ਤੋਂ ਇੱਕ ਸੌ ਬਾਨਵੇ ਤੱਕ, TPC-H 'ਤੇ। ਉਹ ਇਹ ਵੀ ਕਹਿੰਦੇ ਹਨ ਕਿ ਵੱਡੀ ਮਸ਼ੀਨ ਦੇ ਵਾਧੂ ਥ੍ਰੈਡ ਛੋਟੀਆਂ ਪੁੱਛਗਿੱਛਾਂ ਨੂੰ ਹੌਲੀ ਕਰ ਦਿੰਦੇ ਹਨ।
ਜਦੋਂ ਅਸੀਂ ਇਸਨੂੰ ਚਲਾਉਂਦੇ ਹਾਂ ਤਾਂ ਅਸੀਂ ਕੀ ਦੇਖਦੇ ਹਾਂ?
1:41 ਅਸੀਂ Polars 2.0.0 'ਤੇ ਉਸੇ ਜੁਆਇਨ ਨੂੰ ਦੋ ਵਾਰ ਚਲਾਇਆ। ਡਿਫੌਲਟ ਰਨ ਕਤਾਰਾਂ ਨੂੰ ਸ਼ਫਲ ਕਰਦਾ ਹੈ। ਫਲੈਗ ਨਾਲ, ਇਨਪੁਟ ਕ੍ਰਮ ਬਚ ਜਾਂਦਾ ਹੈ। ਉਹਨਾਂ ਜੁਆਇਨਾਂ ਨੂੰ ਲੱਭੋ ਜੋ ਇੱਕ ਟੈਸਟ ਨੂੰ ਫੀਡ ਕਰਦੇ ਹਨ। ਇਸ ਤੋਂ ਬਾਅਦ sort ਤੋਂ ਬਿਨਾਂ ਕੋਈ ਵੀ ਜੁਆਇਨ ਇੱਕ ਕਤਾਰ ਕ੍ਰਮ ਦਾ ਫੈਸਲਾ ਹੈ ਜੋ ਤੁਸੀਂ ਕਦੇ ਨਹੀਂ ਲਿਆ। ਪੋਲਰਸ 2.0 ਕਿਸਮਾਂ ਬਾਰੇ ਸਖ਼ਤ ਹੈ।
ਕੀ ਸਖ਼ਤ ਹੋਣ ਦਾ ਮਤਲਬ ਪਹਿਲਾਂ ਹੈ?
1:58 ਸਕੀਮਾ ਜਾਂਚ ਕਿਸੇ ਵੀ ਡਾਟੇ ਨੂੰ ਪੜ੍ਹਨ ਤੋਂ ਪਹਿਲਾਂ ਇੱਕ ਗੁੰਮ ਕਾਲਮ ਨੂੰ ਫੜ ਲੈਂਦੀ ਹੈ। ਇਹ ਇੱਕ ਕਾਸਟ ਨੂੰ ਨਹੀਂ ਫੜ ਸਕਦਾ ਜੋ ਇੱਕ ਕਤਾਰ 'ਤੇ ਅਸਫਲ ਹੁੰਦਾ ਹੈ, ਕਿਉਂਕਿ ਉਹ ਗਲਤੀ ਡਾਟੇ ਦੀ ਉਡੀਕ ਕਰਦੀ ਹੈ। ਹੁਣ ਉਹ ਲੂਪ ਜੋ ਮੈਂ ਖੋਲ੍ਹਿਆ ਹੈ।
ਮੈਂ ਪੁਰਾਣਾ ਆਰਡਰ ਵਾਪਸ ਕਿਵੇਂ ਪ੍ਰਾਪਤ ਕਰਾਂ?
2:08 ਸਵਿੱਚ ਜੁਆਇਨ 'ਤੇ ਰਹਿੰਦਾ ਹੈ। ਜੁਆਇਨ 'ਤੇ maintain order ਸੈੱਟ ਕਰੋ, ਜਾਂ ਇਸ ਤੋਂ ਬਾਅਦ ਇੱਕ sort ਸ਼ਾਮਲ ਕਰੋ। ਗਾਈਡ sort ਦੀ ਸਿਫ਼ਾਰਸ਼ ਕਰਦੀ ਹੈ। ਜੁਆਇਨ ਫਲੈਗ ਨੇ ਸਾਡੇ ਚੱਲਣ ਵਿੱਚ ਕ੍ਰਮ ਨੂੰ ਬਰਕਰਾਰ ਰੱਖਿਆ, ਖੱਬੇ ਪਾਸੇ ਦੇ ਕ੍ਰਮ ਨੂੰ ਖੱਬੇ, ਸੱਜੇ ਵਜੋਂ ਰੱਖਿਆ ਗਿਆ। ਫੈਸਲਾ, ਪਰਦੇ ਦੇ ਪਿੱਛੇ: ਸਮੀਖਿਆ ਦੀ ਲੋੜ ਹੈ।
ਫੈਸਲਾ ਕੀ ਹੈ?
2:22 ਮੈਂ ਅੱਪਗ੍ਰੇਡ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਹਰ ਜੁਆਇਨ ਦੀ ਸਮੀਖਿਆ ਕਰਾਂਗਾ। ਇਸ ਬਾਰੇ ਕੋਈ ਸਵਾਲ ਹੈ? ਇਸਨੂੰ ਟਿੱਪਣੀਆਂ ਵਿੱਚ ਪਾਓ। ਅਤੇ ਇਹ ਅੱਜ ਲਈ diff ਹੈ। ਮੈਂ ਐਕਸਰਿਸੀ ਤੋਂ ਨਿਕੋ ਹਾਂ। ਜ਼ਿੰਮੇਵਾਰੀ ਨਾਲ ਮਰਜ ਕਰੋ।
ਸਰੋਤ
- 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
