ਰੀਅਲ-ਟਾਈਮ ਸੇਵਾ ਦੀ ਉਦਾਹਰਣ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ Q ਅਤੇ KDB+ ਭਾਸ਼ਾ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ

ਤੁਸੀਂ ਇਸ ਬਾਰੇ ਪੜ੍ਹ ਸਕਦੇ ਹੋ ਕਿ KDB+ ਅਧਾਰ, Q ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਕੀ ਹਨ, ਉਹਨਾਂ ਦੀਆਂ ਸ਼ਕਤੀਆਂ ਅਤੇ ਕਮਜ਼ੋਰੀਆਂ ਮੇਰੇ ਪਿਛਲੇ ਵਿੱਚ ਕੀ ਹਨ ਲੇਖ ਅਤੇ ਸੰਖੇਪ ਵਿੱਚ ਜਾਣ-ਪਛਾਣ ਵਿੱਚ। ਲੇਖ ਵਿੱਚ, ਅਸੀਂ Q 'ਤੇ ਇੱਕ ਸੇਵਾ ਲਾਗੂ ਕਰਾਂਗੇ ਜੋ ਆਉਣ ਵਾਲੇ ਡੇਟਾ ਸਟ੍ਰੀਮ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰੇਗੀ ਅਤੇ "ਰੀਅਲ ਟਾਈਮ" ਮੋਡ ਵਿੱਚ ਹਰ ਮਿੰਟ ਵੱਖ-ਵੱਖ ਏਕੀਕਰਣ ਫੰਕਸ਼ਨਾਂ ਦੀ ਗਣਨਾ ਕਰੇਗੀ (ਅਰਥਾਤ, ਇਸ ਕੋਲ ਡੇਟਾ ਦੇ ਅਗਲੇ ਹਿੱਸੇ ਤੋਂ ਪਹਿਲਾਂ ਹਰ ਚੀਜ਼ ਦੀ ਗਣਨਾ ਕਰਨ ਦਾ ਸਮਾਂ ਹੋਵੇਗਾ)। Q ਦੀ ਮੁੱਖ ਵਿਸ਼ੇਸ਼ਤਾ ਇਹ ਹੈ ਕਿ ਇਹ ਇੱਕ ਵੈਕਟਰ ਭਾਸ਼ਾ ਹੈ ਜੋ ਤੁਹਾਨੂੰ ਸਿੰਗਲ ਆਬਜੈਕਟ ਨਾਲ ਨਹੀਂ, ਸਗੋਂ ਉਹਨਾਂ ਦੇ ਐਰੇ, ਐਰੇ ਦੇ ਐਰੇ ਅਤੇ ਹੋਰ ਗੁੰਝਲਦਾਰ ਵਸਤੂਆਂ ਨਾਲ ਕੰਮ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀ ਹੈ। Q ਅਤੇ ਇਸਦੇ ਰਿਸ਼ਤੇਦਾਰ K, J, APL ਵਰਗੀਆਂ ਭਾਸ਼ਾਵਾਂ ਆਪਣੀ ਸੰਖੇਪਤਾ ਲਈ ਮਸ਼ਹੂਰ ਹਨ। ਅਕਸਰ, ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਜੋ Java ਵਰਗੀ ਇੱਕ ਜਾਣੀ-ਪਛਾਣੀ ਭਾਸ਼ਾ ਵਿੱਚ ਕੋਡ ਦੀਆਂ ਕਈ ਸਕ੍ਰੀਨਾਂ ਲੈਂਦਾ ਹੈ, ਉਹਨਾਂ ਉੱਤੇ ਕੁਝ ਲਾਈਨਾਂ ਵਿੱਚ ਲਿਖਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਇਹ ਉਹ ਹੈ ਜੋ ਮੈਂ ਇਸ ਲੇਖ ਵਿੱਚ ਪ੍ਰਦਰਸ਼ਿਤ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹਾਂ.

ਜਾਣ ਪਛਾਣ

KDB+ ਇੱਕ ਕਾਲਮ ਡੇਟਾਬੇਸ ਹੈ ਜੋ ਬਹੁਤ ਵੱਡੀ ਮਾਤਰਾ ਵਿੱਚ ਡੇਟਾ 'ਤੇ ਕੇਂਦ੍ਰਿਤ ਹੈ, ਇੱਕ ਖਾਸ ਤਰੀਕੇ ਨਾਲ ਆਰਡਰ ਕੀਤਾ ਗਿਆ ਹੈ (ਮੁੱਖ ਤੌਰ 'ਤੇ ਸਮੇਂ ਦੁਆਰਾ)। ਇਹ ਮੁੱਖ ਤੌਰ 'ਤੇ ਵਿੱਤੀ ਸੰਸਥਾਵਾਂ - ਬੈਂਕਾਂ, ਨਿਵੇਸ਼ ਫੰਡਾਂ, ਬੀਮਾ ਕੰਪਨੀਆਂ ਵਿੱਚ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। Q ਭਾਸ਼ਾ KDB+ ਦੀ ਅੰਦਰੂਨੀ ਭਾਸ਼ਾ ਹੈ ਜੋ ਤੁਹਾਨੂੰ ਇਸ ਡੇਟਾ ਨਾਲ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਕੰਮ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀ ਹੈ। Q ਵਿਚਾਰਧਾਰਾ ਸੰਖੇਪਤਾ ਅਤੇ ਕੁਸ਼ਲਤਾ ਹੈ, ਜਦੋਂ ਕਿ ਸਪਸ਼ਟਤਾ ਦੀ ਬਲੀ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ ਇਸ ਤੱਥ ਦੁਆਰਾ ਜਾਇਜ਼ ਹੈ ਕਿ ਵੈਕਟਰ ਭਾਸ਼ਾ ਨੂੰ ਕਿਸੇ ਵੀ ਸਥਿਤੀ ਵਿੱਚ ਸਮਝਣਾ ਮੁਸ਼ਕਲ ਹੋਵੇਗਾ, ਅਤੇ ਰਿਕਾਰਡਿੰਗ ਦੀ ਸੰਖੇਪਤਾ ਅਤੇ ਭਰਪੂਰਤਾ ਤੁਹਾਨੂੰ ਇੱਕ ਸਕ੍ਰੀਨ ਤੇ ਪ੍ਰੋਗਰਾਮ ਦੇ ਬਹੁਤ ਵੱਡੇ ਹਿੱਸੇ ਨੂੰ ਵੇਖਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ, ਜੋ ਆਖਰਕਾਰ ਇਸਨੂੰ ਸਮਝਣਾ ਸੌਖਾ ਬਣਾਉਂਦਾ ਹੈ।

ਇਸ ਲੇਖ ਵਿੱਚ ਅਸੀਂ Q ਵਿੱਚ ਇੱਕ ਪੂਰਾ ਪ੍ਰੋਗਰਾਮ ਲਾਗੂ ਕੀਤਾ ਹੈ ਅਤੇ ਤੁਸੀਂ ਇਸਨੂੰ ਅਜ਼ਮਾਉਣਾ ਚਾਹ ਸਕਦੇ ਹੋ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਅਸਲ Q ਦੀ ਲੋੜ ਪਵੇਗੀ। ਤੁਸੀਂ kx ਕੰਪਨੀ ਦੀ ਵੈੱਬਸਾਈਟ 'ਤੇ ਮੁਫ਼ਤ 32-ਬਿਟ ਸੰਸਕਰਣ ਡਾਊਨਲੋਡ ਕਰ ਸਕਦੇ ਹੋ - www.kx.com. ਉੱਥੇ, ਜੇਕਰ ਤੁਸੀਂ ਦਿਲਚਸਪੀ ਰੱਖਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ Q, ਕਿਤਾਬ ਬਾਰੇ ਹਵਾਲਾ ਜਾਣਕਾਰੀ ਮਿਲੇਗੀ ਪ੍ਰਾਣਾਂ ਲਈ Q ਅਤੇ ਇਸ ਵਿਸ਼ੇ 'ਤੇ ਵੱਖ-ਵੱਖ ਲੇਖ।

ਸਮੱਸਿਆ ਦਾ ਗਠਨ

ਇੱਕ ਸਰੋਤ ਹੈ ਜੋ ਹਰ 25 ਮਿਲੀਸਕਿੰਟ ਵਿੱਚ ਡੇਟਾ ਦੇ ਨਾਲ ਇੱਕ ਸਾਰਣੀ ਭੇਜਦਾ ਹੈ। ਕਿਉਂਕਿ KDB+ ਦੀ ਵਰਤੋਂ ਮੁੱਖ ਤੌਰ 'ਤੇ ਵਿੱਤ ਵਿੱਚ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਅਸੀਂ ਮੰਨ ਲਵਾਂਗੇ ਕਿ ਇਹ ਲੈਣ-ਦੇਣ (ਵਪਾਰ) ਦੀ ਇੱਕ ਸਾਰਣੀ ਹੈ, ਜਿਸ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤੇ ਕਾਲਮ ਹਨ: ਸਮਾਂ (ਸਮਾਂ ਮਿਲੀਸਕਿੰਟ ਵਿੱਚ), ਸਿਮ (ਸਟਾਕ ਐਕਸਚੇਂਜ 'ਤੇ ਕੰਪਨੀ ਦਾ ਅਹੁਦਾ - IBM, AAPL,…), ਕੀਮਤ (ਉਹ ਕੀਮਤ ਜਿਸ 'ਤੇ ਸ਼ੇਅਰ ਖਰੀਦੇ ਗਏ ਸਨ), ਆਕਾਰ (ਲੈਣ-ਦੇਣ ਦਾ ਆਕਾਰ)। 25 ਮਿਲੀਸਕਿੰਟ ਅੰਤਰਾਲ ਮਨਮਾਨੀ ਹੈ, ਨਾ ਬਹੁਤ ਛੋਟਾ ਅਤੇ ਨਾ ਬਹੁਤ ਲੰਬਾ। ਇਸਦੀ ਮੌਜੂਦਗੀ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਡੇਟਾ ਪਹਿਲਾਂ ਹੀ ਬਫਰ ਕੀਤੀ ਸੇਵਾ ਵਿੱਚ ਆਉਂਦਾ ਹੈ। ਮੌਜੂਦਾ ਲੋਡ ਦੇ ਆਧਾਰ 'ਤੇ ਗਤੀਸ਼ੀਲ ਬਫਰਿੰਗ ਸਮੇਤ, ਸੇਵਾ ਵਾਲੇ ਪਾਸੇ ਬਫਰਿੰਗ ਨੂੰ ਲਾਗੂ ਕਰਨਾ ਆਸਾਨ ਹੋਵੇਗਾ, ਪਰ ਸਰਲਤਾ ਲਈ, ਅਸੀਂ ਇੱਕ ਨਿਸ਼ਚਿਤ ਅੰਤਰਾਲ 'ਤੇ ਧਿਆਨ ਦੇਵਾਂਗੇ।

ਸੇਵਾ ਨੂੰ ਸਿਮ ਕਾਲਮ ਤੋਂ ਹਰੇਕ ਆਉਣ ਵਾਲੇ ਪ੍ਰਤੀਕ ਲਈ ਹਰ ਮਿੰਟ ਦੀ ਗਿਣਤੀ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ ਇੱਕ ਸਮੂਹਿਕ ਫੰਕਸ਼ਨਾਂ ਦਾ ਇੱਕ ਸੈੱਟ - ਅਧਿਕਤਮ ਕੀਮਤ, ਔਸਤ ਕੀਮਤ, ਜੋੜ ਦਾ ਆਕਾਰ, ਆਦਿ। ਲਾਭਦਾਇਕ ਜਾਣਕਾਰੀ. ਸਰਲਤਾ ਲਈ, ਅਸੀਂ ਇਹ ਮੰਨ ਲਵਾਂਗੇ ਕਿ ਸਾਰੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਗਣਨਾ ਲਗਾਤਾਰ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ. ਇੱਕ ਨਵਾਂ ਮੁੱਲ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ, ਦੋ ਨੰਬਰਾਂ ਨੂੰ ਜਾਣਨਾ ਕਾਫ਼ੀ ਹੈ - ਪੁਰਾਣੇ ਅਤੇ ਆਉਣ ਵਾਲੇ ਮੁੱਲ। ਉਦਾਹਰਨ ਲਈ, ਫੰਕਸ਼ਨ ਅਧਿਕਤਮ, ਔਸਤ, ਜੋੜ ਵਿੱਚ ਇਹ ਵਿਸ਼ੇਸ਼ਤਾ ਹੈ, ਪਰ ਮੱਧਮ ਫੰਕਸ਼ਨ ਨਹੀਂ ਹੈ।

ਅਸੀਂ ਇਹ ਵੀ ਮੰਨ ਲਵਾਂਗੇ ਕਿ ਇਨਕਮਿੰਗ ਡੇਟਾ ਸਟ੍ਰੀਮ ਦਾ ਸਮਾਂ ਆਰਡਰ ਕੀਤਾ ਗਿਆ ਹੈ। ਇਸ ਨਾਲ ਸਾਨੂੰ ਆਖਰੀ ਸਮੇਂ ਤੱਕ ਕੰਮ ਕਰਨ ਦਾ ਮੌਕਾ ਮਿਲੇਗਾ। ਅਭਿਆਸ ਵਿੱਚ, ਕੁਝ ਅੱਪਡੇਟ ਦੇਰ ਨਾਲ ਹੋਣ ਦੀ ਸਥਿਤੀ ਵਿੱਚ ਮੌਜੂਦਾ ਅਤੇ ਪਿਛਲੇ ਮਿੰਟਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਦੇ ਯੋਗ ਹੋਣਾ ਕਾਫ਼ੀ ਹੈ. ਸਾਦਗੀ ਲਈ, ਅਸੀਂ ਇਸ ਕੇਸ 'ਤੇ ਵਿਚਾਰ ਨਹੀਂ ਕਰਾਂਗੇ.

ਏਗਰੀਗੇਸ਼ਨ ਫੰਕਸ਼ਨ

ਲੋੜੀਂਦੇ ਐਗਰੀਗੇਸ਼ਨ ਫੰਕਸ਼ਨ ਹੇਠਾਂ ਦਿੱਤੇ ਗਏ ਹਨ। ਮੈਂ ਸੇਵਾ 'ਤੇ ਲੋਡ ਵਧਾਉਣ ਲਈ ਉਨ੍ਹਾਂ ਵਿੱਚੋਂ ਵੱਧ ਤੋਂ ਵੱਧ ਲਿਆ:

• ਉੱਚ - ਅਧਿਕਤਮ ਕੀਮਤ - ਪ੍ਰਤੀ ਮਿੰਟ ਵੱਧ ਤੋਂ ਵੱਧ ਕੀਮਤ।
• ਘੱਟ - ਘੱਟੋ-ਘੱਟ ਕੀਮਤ - ਪ੍ਰਤੀ ਮਿੰਟ ਘੱਟੋ-ਘੱਟ ਕੀਮਤ।
• ਪਹਿਲੀ ਕੀਮਤ - ਪਹਿਲੀ ਕੀਮਤ - ਪ੍ਰਤੀ ਮਿੰਟ ਪਹਿਲੀ ਕੀਮਤ।
• ਆਖਰੀ ਕੀਮਤ - ਆਖਰੀ ਕੀਮਤ - ਆਖਰੀ ਕੀਮਤ ਪ੍ਰਤੀ ਮਿੰਟ।
• ਪਹਿਲਾ ਆਕਾਰ - ਪਹਿਲਾ ਆਕਾਰ - ਪ੍ਰਤੀ ਮਿੰਟ ਪਹਿਲਾ ਵਪਾਰ ਆਕਾਰ।
• lastSize - ਆਖਰੀ ਆਕਾਰ - ਇੱਕ ਮਿੰਟ ਵਿੱਚ ਆਖਰੀ ਵਪਾਰ ਦਾ ਆਕਾਰ।
• numTrades - ਗਿਣਤੀ i - ਪ੍ਰਤੀ ਮਿੰਟ ਵਪਾਰਾਂ ਦੀ ਗਿਣਤੀ।
• ਵਾਲੀਅਮ - ਜੋੜ ਦਾ ਆਕਾਰ - ਪ੍ਰਤੀ ਮਿੰਟ ਵਪਾਰ ਦੇ ਆਕਾਰ ਦਾ ਜੋੜ।
• pvolume - ਜੋੜ ਕੀਮਤ - ਪ੍ਰਤੀ ਮਿੰਟ ਕੀਮਤਾਂ ਦਾ ਜੋੜ, ਔਸਤ ਕੀਮਤ ਲਈ ਲੋੜੀਂਦਾ ਹੈ।
• - ਕੁੱਲ ਟਰਨਓਵਰ ਕੀਮਤ * ਆਕਾਰ - ਪ੍ਰਤੀ ਮਿੰਟ ਲੈਣ-ਦੇਣ ਦੀ ਕੁੱਲ ਮਾਤਰਾ।
• avgPrice – pvolume%numTrades – ਔਸਤ ਕੀਮਤ ਪ੍ਰਤੀ ਮਿੰਟ।
• avgSize – ਵਾਲੀਅਮ%numTrades – ਔਸਤ ਵਪਾਰ ਦਾ ਆਕਾਰ ਪ੍ਰਤੀ ਮਿੰਟ।
• vwap - ਟਰਨਓਵਰ% ਵਾਲੀਅਮ - ਔਸਤ ਕੀਮਤ ਪ੍ਰਤੀ ਮਿੰਟ ਲੈਣ-ਦੇਣ ਦੇ ਆਕਾਰ ਦੁਆਰਾ ਭਾਰ.
• cumVolume - ਜੋੜ ਵਾਲੀਅਮ - ਪੂਰੇ ਸਮੇਂ ਦੌਰਾਨ ਲੈਣ-ਦੇਣ ਦਾ ਸੰਚਿਤ ਆਕਾਰ।

ਆਉ ਤੁਰੰਤ ਇੱਕ ਗੈਰ-ਸਪੱਸ਼ਟ ਬਿੰਦੂ 'ਤੇ ਚਰਚਾ ਕਰੀਏ - ਇਹਨਾਂ ਕਾਲਮਾਂ ਨੂੰ ਪਹਿਲੀ ਵਾਰ ਅਤੇ ਹਰ ਅਗਲੇ ਮਿੰਟ ਲਈ ਕਿਵੇਂ ਸ਼ੁਰੂ ਕਰਨਾ ਹੈ। ਪਹਿਲੀ ਕੀਮਤ ਕਿਸਮ ਦੇ ਕੁਝ ਕਾਲਮਾਂ ਨੂੰ ਹਰ ਵਾਰ ਰੱਦ ਕਰਨ ਲਈ ਸ਼ੁਰੂ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ; ਹੋਰ ਵਾਲੀਅਮ ਕਿਸਮਾਂ ਨੂੰ ਹਮੇਸ਼ਾ 0 'ਤੇ ਸੈੱਟ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਇੱਥੇ ਅਜਿਹੇ ਕਾਲਮ ਵੀ ਹਨ ਜਿਨ੍ਹਾਂ ਲਈ ਇੱਕ ਸੰਯੁਕਤ ਪਹੁੰਚ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ - ਉਦਾਹਰਨ ਲਈ, cumVolume ਨੂੰ ਪਿਛਲੇ ਮਿੰਟ ਤੋਂ ਕਾਪੀ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ, ਅਤੇ ਪਹਿਲੇ ਇੱਕ ਲਈ 0 'ਤੇ ਸੈੱਟ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਆਉ ਸ਼ਬਦਕੋਸ਼ ਡੇਟਾ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇਹਨਾਂ ਸਾਰੇ ਮਾਪਦੰਡਾਂ ਨੂੰ ਸੈੱਟ ਕਰੀਏ। ਟਾਈਪ (ਇੱਕ ਰਿਕਾਰਡ ਦੇ ਸਮਾਨ):

// list ! list – создать словарь, 0n – float null, 0N – long null, `sym – тип символ, `sym1`sym2 – список символов
initWith:`sym`time`high`low`firstPrice`lastPrice`firstSize`lastSize`numTrades`volume`pvolume`turnover`avgPrice`avgSize`vwap`cumVolume!(`;00:00;0n;0n;0n;0n;0N;0N;0;0;0.0;0.0;0n;0n;0n;0);
aggCols:reverse key[initWith] except `sym`time; // список всех вычисляемых колонок, reverse объяснен ниже

ਮੈਂ ਸਹੂਲਤ ਲਈ ਸ਼ਬਦਕੋਸ਼ ਵਿੱਚ ਸਿਮ ਅਤੇ ਸਮਾਂ ਜੋੜਿਆ ਹੈ, ਹੁਣ initWith ਅੰਤਮ ਸਮੁੱਚੀ ਸਾਰਣੀ ਤੋਂ ਇੱਕ ਤਿਆਰ ਲਾਈਨ ਹੈ, ਜਿੱਥੇ ਇਹ ਸਹੀ ਸਿਮ ਅਤੇ ਸਮਾਂ ਨਿਰਧਾਰਤ ਕਰਨਾ ਬਾਕੀ ਹੈ। ਤੁਸੀਂ ਇਸਨੂੰ ਇੱਕ ਸਾਰਣੀ ਵਿੱਚ ਨਵੀਆਂ ਕਤਾਰਾਂ ਜੋੜਨ ਲਈ ਵਰਤ ਸਕਦੇ ਹੋ।

ਏਗਰੀਗੇਸ਼ਨ ਫੰਕਸ਼ਨ ਬਣਾਉਣ ਵੇਲੇ ਸਾਨੂੰ ਐਗਕੋਲਸ ਦੀ ਲੋੜ ਪਵੇਗੀ। ਸੂਚੀ ਨੂੰ ਉਸ ਕ੍ਰਮ ਦੇ ਕਾਰਨ ਉਲਟ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਜਿਸ ਵਿੱਚ Q ਵਿੱਚ ਸਮੀਕਰਨਾਂ ਦਾ ਮੁਲਾਂਕਣ ਕੀਤਾ ਜਾਂਦਾ ਹੈ (ਸੱਜੇ ਤੋਂ ਖੱਬੇ)। ਟੀਚਾ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਹੈ ਕਿ ਗਣਨਾ ਉੱਚ ਤੋਂ ਕਮ-ਵੋਲਿਊਮ ਤੱਕ ਜਾਵੇ, ਕਿਉਂਕਿ ਕੁਝ ਕਾਲਮ ਪਿਛਲੇ ਕਾਲਮ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ।

ਕਾਲਮ ਜਿਨ੍ਹਾਂ ਨੂੰ ਪਿਛਲੇ ਇੱਕ ਤੋਂ ਇੱਕ ਨਵੇਂ ਮਿੰਟ ਵਿੱਚ ਕਾਪੀ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਸਹੂਲਤ ਲਈ ਸਿਮ ਕਾਲਮ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ:

rollColumns:`sym`cumVolume;

ਆਉ ਹੁਣ ਕਾਲਮਾਂ ਨੂੰ ਸਮੂਹਾਂ ਵਿੱਚ ਵੰਡੀਏ ਕਿ ਉਹਨਾਂ ਨੂੰ ਕਿਵੇਂ ਅਪਡੇਟ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਤਿੰਨ ਕਿਸਮਾਂ ਨੂੰ ਵੱਖ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ:

1. ਇਕੱਤਰ ਕਰਨ ਵਾਲੇ (ਵਾਲੀਅਮ, ਟਰਨਓਵਰ,..) - ਸਾਨੂੰ ਆਉਣ ਵਾਲੇ ਮੁੱਲ ਨੂੰ ਪਿਛਲੇ ਇੱਕ ਵਿੱਚ ਜੋੜਨਾ ਚਾਹੀਦਾ ਹੈ।
2. ਇੱਕ ਵਿਸ਼ੇਸ਼ ਬਿੰਦੂ (ਉੱਚ, ਨੀਵਾਂ, ..) ਦੇ ਨਾਲ - ਮਿੰਟ ਵਿੱਚ ਪਹਿਲਾ ਮੁੱਲ ਆਉਣ ਵਾਲੇ ਡੇਟਾ ਤੋਂ ਲਿਆ ਜਾਂਦਾ ਹੈ, ਬਾਕੀ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ।
3. ਆਰਾਮ. ਹਮੇਸ਼ਾਂ ਇੱਕ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਗਣਨਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

ਆਉ ਇਹਨਾਂ ਕਲਾਸਾਂ ਲਈ ਵੇਰੀਏਬਲ ਪਰਿਭਾਸ਼ਿਤ ਕਰੀਏ:

accumulatorCols:`numTrades`volume`pvolume`turnover;
specialCols:`high`low`firstPrice`firstSize;

ਗਣਨਾ ਕ੍ਰਮ

ਅਸੀਂ ਏਕੀਕ੍ਰਿਤ ਸਾਰਣੀ ਨੂੰ ਦੋ ਪੜਾਵਾਂ ਵਿੱਚ ਅਪਡੇਟ ਕਰਾਂਗੇ। ਕੁਸ਼ਲਤਾ ਲਈ, ਅਸੀਂ ਪਹਿਲਾਂ ਆਉਣ ਵਾਲੀ ਸਾਰਣੀ ਨੂੰ ਸੁੰਗੜਦੇ ਹਾਂ ਤਾਂ ਜੋ ਹਰੇਕ ਅੱਖਰ ਅਤੇ ਮਿੰਟ ਲਈ ਸਿਰਫ ਇੱਕ ਕਤਾਰ ਹੋਵੇ। ਇਹ ਤੱਥ ਕਿ ਸਾਡੇ ਸਾਰੇ ਫੰਕਸ਼ਨ ਵਾਧੇ ਵਾਲੇ ਅਤੇ ਸਹਿਯੋਗੀ ਹਨ ਇਹ ਗਾਰੰਟੀ ਦਿੰਦਾ ਹੈ ਕਿ ਇਸ ਵਾਧੂ ਕਦਮ ਦਾ ਨਤੀਜਾ ਨਹੀਂ ਬਦਲੇਗਾ। ਤੁਸੀਂ ਇੱਕ ਚੋਣ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸਾਰਣੀ ਨੂੰ ਸੁੰਗੜ ਸਕਦੇ ਹੋ:

select high:max price, low:min price … by sym,time.minute from table

ਇਸ ਵਿਧੀ ਦਾ ਇੱਕ ਨੁਕਸਾਨ ਹੈ - ਗਣਨਾ ਕੀਤੇ ਕਾਲਮਾਂ ਦਾ ਸੈੱਟ ਪਹਿਲਾਂ ਤੋਂ ਪਰਿਭਾਸ਼ਿਤ ਹੈ। ਖੁਸ਼ਕਿਸਮਤੀ ਨਾਲ, Q ਵਿੱਚ, ਚੋਣ ਨੂੰ ਇੱਕ ਫੰਕਸ਼ਨ ਵਜੋਂ ਵੀ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ ਜਿੱਥੇ ਤੁਸੀਂ ਗਤੀਸ਼ੀਲ ਤੌਰ 'ਤੇ ਬਣਾਏ ਆਰਗੂਮੈਂਟਾਂ ਨੂੰ ਬਦਲ ਸਕਦੇ ਹੋ:

?[table;whereClause;byClause;selectClause]

ਮੈਂ ਸਾਡੇ ਕੇਸ ਵਿੱਚ ਆਰਗੂਮੈਂਟਾਂ ਦੇ ਫਾਰਮੈਟ ਦਾ ਵਿਸਥਾਰ ਵਿੱਚ ਵਰਣਨ ਨਹੀਂ ਕਰਾਂਗਾ; ਇਸ ਤਰ੍ਹਾਂ, ਸੁੰਗੜਨ ਵਾਲੇ ਫੰਕਸ਼ਨ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ:

selExpression:`high`low`firstPrice`lastPrice`firstSize`lastSize`numTrades`volume`pvolume`turnover!parse each ("max price";"min price";"first price";"last price";"first size";"last size";"count i";"sum size";"sum price";"sum price*size"); // each это функция map в Q для одного списка
preprocess:?[;();`sym`time!`sym`time.minute;selExpression];

ਸਪਸ਼ਟਤਾ ਲਈ, ਮੈਂ ਪਾਰਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕੀਤੀ, ਜੋ ਕਿ Q ਸਮੀਕਰਨ ਵਾਲੀ ਇੱਕ ਸਟ੍ਰਿੰਗ ਨੂੰ ਇੱਕ ਮੁੱਲ ਵਿੱਚ ਬਦਲਦਾ ਹੈ ਜੋ ਈਵਲ ਫੰਕਸ਼ਨ ਨੂੰ ਪਾਸ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ਜੋ ਫੰਕਸ਼ਨ ਚੋਣ ਵਿੱਚ ਲੋੜੀਂਦਾ ਹੈ। ਇਹ ਵੀ ਨੋਟ ਕਰੋ ਕਿ ਪ੍ਰੀਪ੍ਰੋਸੈਸ ਨੂੰ ਚੋਣਵੇਂ ਫੰਕਸ਼ਨ ਦੇ ਇੱਕ ਪ੍ਰੋਜੇਕਸ਼ਨ (ਅਰਥਾਤ, ਅੰਸ਼ਕ ਤੌਰ 'ਤੇ ਪਰਿਭਾਸ਼ਿਤ ਆਰਗੂਮੈਂਟਾਂ ਵਾਲਾ ਇੱਕ ਫੰਕਸ਼ਨ) ਵਜੋਂ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਇੱਕ ਆਰਗੂਮੈਂਟ (ਸਾਰਣੀ) ਗੁੰਮ ਹੈ। ਜੇਕਰ ਅਸੀਂ ਇੱਕ ਸਾਰਣੀ ਵਿੱਚ ਪ੍ਰੀਪ੍ਰੋਸੈਸ ਲਾਗੂ ਕਰਦੇ ਹਾਂ, ਤਾਂ ਸਾਨੂੰ ਇੱਕ ਸੰਕੁਚਿਤ ਟੇਬਲ ਮਿਲੇਗਾ।

ਦੂਜਾ ਪੜਾਅ ਐਗਰੀਗੇਟਿਡ ਟੇਬਲ ਨੂੰ ਅਪਡੇਟ ਕਰ ਰਿਹਾ ਹੈ। ਆਓ ਪਹਿਲਾਂ ਅਲਗੋਰਿਦਮ ਨੂੰ ਸੂਡੋਕੋਡ ਵਿੱਚ ਲਿਖੀਏ:

for each sym in inputTable
  idx: row index in agg table for sym+currentTime;
  aggTable[idx;`high]: aggTable[idx;`high] | inputTable[sym;`high];
  aggTable[idx;`volume]: aggTable[idx;`volume] + inputTable[sym;`volume];
  …

Q ਵਿੱਚ, ਲੂਪਸ ਦੀ ਬਜਾਏ ਮੈਪ/ਰਿਡਿਊਸ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਆਮ ਗੱਲ ਹੈ। ਪਰ ਕਿਉਂਕਿ Q ਇੱਕ ਵੈਕਟਰ ਭਾਸ਼ਾ ਹੈ ਅਤੇ ਅਸੀਂ ਇੱਕ ਵਾਰ ਵਿੱਚ ਸਾਰੇ ਚਿੰਨ੍ਹਾਂ 'ਤੇ ਸਾਰੇ ਓਪਰੇਸ਼ਨ ਆਸਾਨੀ ਨਾਲ ਲਾਗੂ ਕਰ ਸਕਦੇ ਹਾਂ, ਫਿਰ ਇੱਕ ਪਹਿਲੇ ਅਨੁਮਾਨ ਤੱਕ ਅਸੀਂ ਬਿਨਾਂ ਕਿਸੇ ਲੂਪ ਦੇ ਕਰ ਸਕਦੇ ਹਾਂ, ਇੱਕ ਵਾਰ ਵਿੱਚ ਸਾਰੇ ਚਿੰਨ੍ਹਾਂ 'ਤੇ ਕਾਰਵਾਈਆਂ ਕਰਦੇ ਹੋਏ:

idx:calcIdx inputTable;
row:aggTable idx;
aggTable[idx;`high]: row[`high] | inputTable`high;
aggTable[idx;`volume]: row[`volume] + inputTable`volume;
…

ਪਰ ਅਸੀਂ ਹੋਰ ਅੱਗੇ ਜਾ ਸਕਦੇ ਹਾਂ, Q ਦਾ ਇੱਕ ਵਿਲੱਖਣ ਅਤੇ ਬਹੁਤ ਸ਼ਕਤੀਸ਼ਾਲੀ ਓਪਰੇਟਰ ਹੈ - ਜਨਰਲਾਈਜ਼ਡ ਅਸਾਈਨਮੈਂਟ ਆਪਰੇਟਰ। ਇਹ ਤੁਹਾਨੂੰ ਸੂਚਕਾਂਕ, ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਆਰਗੂਮੈਂਟਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਗੁੰਝਲਦਾਰ ਡੇਟਾ ਢਾਂਚੇ ਵਿੱਚ ਮੁੱਲਾਂ ਦੇ ਇੱਕ ਸਮੂਹ ਨੂੰ ਬਦਲਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਸਾਡੇ ਕੇਸ ਵਿੱਚ ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ:

idx:calcIdx inputTable;
rows:aggTable idx;
// .[target;(idx0;idx1;..);function;argument] ~ target[idx 0;idx 1;…]: function[target[idx 0;idx 1;…];argument], в нашем случае функция – это присваивание
.[aggTable;(idx;aggCols);:;flip (row[`high] | inputTable`high;row[`volume] + inputTable`volume;…)];

ਬਦਕਿਸਮਤੀ ਨਾਲ, ਇੱਕ ਸਾਰਣੀ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਤੁਹਾਨੂੰ ਕਤਾਰਾਂ ਦੀ ਸੂਚੀ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਕਾਲਮਾਂ ਦੀ ਨਹੀਂ, ਅਤੇ ਤੁਹਾਨੂੰ ਫਲਿੱਪ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮੈਟ੍ਰਿਕਸ (ਕਤਾਰਾਂ ਦੀ ਸੂਚੀ ਵਿੱਚ ਕਾਲਮਾਂ ਦੀ ਸੂਚੀ) ਨੂੰ ਟ੍ਰਾਂਸਪੋਜ਼ ਕਰਨਾ ਪੈਂਦਾ ਹੈ। ਇਹ ਇੱਕ ਵੱਡੀ ਟੇਬਲ ਲਈ ਮਹਿੰਗਾ ਹੈ, ਇਸਲਈ ਅਸੀਂ ਮੈਪ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਹਰੇਕ ਕਾਲਮ ਲਈ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਇੱਕ ਆਮ ਅਸਾਈਨਮੈਂਟ ਲਾਗੂ ਕਰਦੇ ਹਾਂ (ਜੋ ਕਿ ਇੱਕ ਅਪੋਸਟ੍ਰੋਫ ਵਰਗਾ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ):

.[aggTable;;:;]'[(idx;)each aggCols; (row[`high] | inputTable`high;row[`volume] + inputTable`volume;…)];

ਅਸੀਂ ਦੁਬਾਰਾ ਫੰਕਸ਼ਨ ਪ੍ਰੋਜੈਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ। ਇਹ ਵੀ ਨੋਟ ਕਰੋ ਕਿ Q ਵਿੱਚ, ਇੱਕ ਸੂਚੀ ਬਣਾਉਣਾ ਵੀ ਇੱਕ ਫੰਕਸ਼ਨ ਹੈ ਅਤੇ ਅਸੀਂ ਸੂਚੀਆਂ ਦੀ ਸੂਚੀ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਹਰੇਕ (ਮੈਪ) ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਸਨੂੰ ਕਾਲ ਕਰ ਸਕਦੇ ਹਾਂ।

ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕਿ ਗਣਨਾ ਕੀਤੇ ਕਾਲਮਾਂ ਦਾ ਸੈੱਟ ਸਥਿਰ ਨਹੀਂ ਹੈ, ਅਸੀਂ ਉਪਰੋਕਤ ਸਮੀਕਰਨ ਨੂੰ ਗਤੀਸ਼ੀਲ ਰੂਪ ਵਿੱਚ ਬਣਾਵਾਂਗੇ। ਆਉ ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਇਕੱਠੇ ਕੀਤੇ ਅਤੇ ਇਨਪੁਟ ਡੇਟਾ ਦਾ ਹਵਾਲਾ ਦੇਣ ਲਈ ਕਤਾਰ ਅਤੇ inp ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਹਰੇਕ ਕਾਲਮ ਦੀ ਗਣਨਾ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੀਏ:

aggExpression:`high`low`firstPrice`lastPrice`firstSize`lastSize`avgPrice`avgSize`vwap`cumVolume!
 ("row[`high]|inp`high";"row[`low]&inp`low";"row`firstPrice";"inp`lastPrice";"row`firstSize";"inp`lastSize";"pvolume%numTrades";"volume%numTrades";"turnover%volume";"row[`cumVolume]+inp`volume");

ਕੁਝ ਕਾਲਮ ਵਿਸ਼ੇਸ਼ ਹੁੰਦੇ ਹਨ; ਉਹਨਾਂ ਦਾ ਪਹਿਲਾ ਮੁੱਲ ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਨਹੀਂ ਗਿਣਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਅਸੀਂ ਇਹ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹਾਂ ਕਿ ਇਹ ਕਤਾਰ [`numTrades] ਕਾਲਮ ਦੁਆਰਾ ਪਹਿਲਾ ਹੈ - ਜੇਕਰ ਇਸ ਵਿੱਚ 0 ਹੈ, ਤਾਂ ਮੁੱਲ ਪਹਿਲਾਂ ਹੈ। Q ਵਿੱਚ ਇੱਕ ਚੋਣ ਫੰਕਸ਼ਨ ਹੈ - ?[Boolian list;list1;list2] - ਜੋ ਕਿ ਪਹਿਲੀ ਆਰਗੂਮੈਂਟ ਵਿੱਚ ਸਥਿਤੀ ਦੇ ਅਧਾਰ ਤੇ ਸੂਚੀ 1 ਜਾਂ 2 ਵਿੱਚੋਂ ਇੱਕ ਮੁੱਲ ਚੁਣਦਾ ਹੈ:

// high -> ?[isFirst;inp`high;row[`high]|inp`high]
// @ - тоже обобщенное присваивание для случая когда индекс неглубокий
@[`aggExpression;specialCols;{[x;y]"?[isFirst;inp`",y,";",x,"]"};string specialCols];

ਇੱਥੇ ਮੈਂ ਆਪਣੇ ਫੰਕਸ਼ਨ (ਕਰਲੀ ਬਰੇਸ ਵਿੱਚ ਇੱਕ ਸਮੀਕਰਨ) ਦੇ ਨਾਲ ਇੱਕ ਆਮ ਅਸਾਈਨਮੈਂਟ ਨੂੰ ਬੁਲਾਇਆ ਹੈ। ਇਹ ਮੌਜੂਦਾ ਮੁੱਲ (ਪਹਿਲੀ ਆਰਗੂਮੈਂਟ) ਅਤੇ ਇੱਕ ਵਾਧੂ ਆਰਗੂਮੈਂਟ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ, ਜੋ ਮੈਂ 4 ਪੈਰਾਮੀਟਰ ਵਿੱਚ ਪਾਸ ਕਰਦਾ ਹਾਂ।

ਆਓ ਬੈਟਰੀ ਸਪੀਕਰਾਂ ਨੂੰ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਜੋੜੀਏ, ਕਿਉਂਕਿ ਫੰਕਸ਼ਨ ਉਹਨਾਂ ਲਈ ਇੱਕੋ ਜਿਹਾ ਹੈ:

// volume -> row[`volume]+inp`volume
aggExpression[accumulatorCols]:{"row[`",x,"]+inp`",x } each string accumulatorCols;

ਇਹ Q ਮਿਆਰਾਂ ਦੁਆਰਾ ਇੱਕ ਆਮ ਅਸਾਈਨਮੈਂਟ ਹੈ, ਪਰ ਮੈਂ ਇੱਕ ਵਾਰ ਵਿੱਚ ਮੁੱਲਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਨਿਰਧਾਰਤ ਕਰ ਰਿਹਾ/ਰਹੀ ਹਾਂ। ਅੰਤ ਵਿੱਚ, ਆਓ ਮੁੱਖ ਫੰਕਸ਼ਨ ਬਣਾਈਏ:

// ":",/:aggExprs ~ map[{":",x};aggExpr] => ":row[`high]|inp`high" присвоим вычисленное значение переменной, потому что некоторые колонки зависят от уже вычисленных значений
// string[cols],'exprs ~ map[,;string[cols];exprs] => "high:row[`high]|inp`high" завершим создание присваивания. ,’ расшифровывается как map[concat]
// ";" sv exprs – String from Vector (sv), соединяет список строк вставляя “;” посредине
updateAgg:value "{[aggTable;idx;inp] row:aggTable idx; isFirst_0=row`numTrades; .[aggTable;;:;]'[(idx;)each aggCols;(",(";"sv string[aggCols],'":",/:aggExpression aggCols),")]}";

ਇਸ ਸਮੀਕਰਨ ਦੇ ਨਾਲ, ਮੈਂ ਗਤੀਸ਼ੀਲ ਤੌਰ 'ਤੇ ਇੱਕ ਸਟ੍ਰਿੰਗ ਤੋਂ ਇੱਕ ਫੰਕਸ਼ਨ ਬਣਾਉਂਦਾ ਹਾਂ ਜਿਸ ਵਿੱਚ ਉਪਰੋਕਤ ਸਮੀਕਰਨ ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ। ਨਤੀਜਾ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਵੇਗਾ:

{[aggTable;idx;inp] rows:aggTable idx; isFirst_0=row`numTrades; .[aggTable;;:;]'[(idx;)each aggCols ;(cumVolume:row[`cumVolume]+inp`cumVolume;… ; high:?[isFirst;inp`high;row[`high]|inp`high])]}

ਕਾਲਮ ਮੁਲਾਂਕਣ ਕ੍ਰਮ ਉਲਟ ਹੈ ਕਿਉਂਕਿ Q ਵਿੱਚ ਮੁਲਾਂਕਣ ਕ੍ਰਮ ਸੱਜੇ ਤੋਂ ਖੱਬੇ ਹੁੰਦਾ ਹੈ।

ਹੁਣ ਸਾਡੇ ਕੋਲ ਗਣਨਾ ਲਈ ਦੋ ਮੁੱਖ ਫੰਕਸ਼ਨ ਜ਼ਰੂਰੀ ਹਨ, ਸਾਨੂੰ ਸਿਰਫ ਥੋੜਾ ਜਿਹਾ ਬੁਨਿਆਦੀ ਢਾਂਚਾ ਜੋੜਨ ਦੀ ਲੋੜ ਹੈ ਅਤੇ ਸੇਵਾ ਤਿਆਰ ਹੈ।

ਅੰਤਮ ਕਦਮ

ਸਾਡੇ ਕੋਲ ਪ੍ਰੀਪ੍ਰੋਸੈਸ ਅਤੇ ਅਪਡੇਟ ਏਗ ਫੰਕਸ਼ਨ ਹਨ ਜੋ ਸਾਰੇ ਕੰਮ ਕਰਦੇ ਹਨ। ਪਰ ਇਹ ਅਜੇ ਵੀ ਜ਼ਰੂਰੀ ਹੈ ਕਿ ਮਿੰਟਾਂ ਰਾਹੀਂ ਸਹੀ ਪਰਿਵਰਤਨ ਯਕੀਨੀ ਬਣਾਇਆ ਜਾਵੇ ਅਤੇ ਏਕੀਕਰਣ ਲਈ ਸੂਚਕਾਂਕ ਦੀ ਗਣਨਾ ਕੀਤੀ ਜਾਵੇ। ਸਭ ਤੋਂ ਪਹਿਲਾਂ, ਆਓ init ਫੰਕਸ਼ਨ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੀਏ:

init:{
  tradeAgg:: 0#enlist[initWith]; // создаем пустую типизированную таблицу, enlist превращает словарь в таблицу, а 0# означает взять 0 элементов из нее
  currTime::00:00; // начнем с 0, :: означает, что присваивание в глобальную переменную
  currSyms::`u#`symbol$(); // `u# - превращает список в дерево, для ускорения поиска элементов
  offset::0; // индекс в tradeAgg, где начинается текущая минута 
  rollCache:: `sym xkey update `u#sym from rollColumns#tradeAgg; // кэш для последних значений roll колонок, таблица с ключом sym
 }

ਅਸੀਂ ਰੋਲ ਫੰਕਸ਼ਨ ਨੂੰ ਵੀ ਪਰਿਭਾਸ਼ਿਤ ਕਰਾਂਗੇ, ਜੋ ਮੌਜੂਦਾ ਮਿੰਟ ਨੂੰ ਬਦਲ ਦੇਵੇਗਾ:

roll:{[tm]
  if[currTime>tm; :init[]]; // если перевалили за полночь, то просто вызовем init
  rollCache,::offset _ rollColumns#tradeAgg; // обновим кэш – взять roll колонки из aggTable, обрезать, вставить в rollCache
  offset::count tradeAgg;
  currSyms::`u#`$();
 }

ਸਾਨੂੰ ਨਵੇਂ ਅੱਖਰ ਜੋੜਨ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਦੀ ਲੋੜ ਪਵੇਗੀ:

addSyms:{[syms]
  currSyms,::syms; // добавим в список известных
  // добавим в таблицу sym, time и rollColumns воспользовавшись обобщенным присваиванием.
  // Функция ^ подставляет значения по умолчанию для roll колонок, если символа нет в кэше. value flip table возвращает список колонок в таблице.
  `tradeAgg upsert @[count[syms]#enlist initWith;`sym`time,cols rc;:;(syms;currTime), (initWith cols rc)^value flip rc:rollCache ([] sym: syms)];
 }

ਅਤੇ ਅੰਤ ਵਿੱਚ, upd ਫੰਕਸ਼ਨ (Q ਸੇਵਾਵਾਂ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦਾ ਰਵਾਇਤੀ ਨਾਮ), ਜਿਸ ਨੂੰ ਕਲਾਇੰਟ ਦੁਆਰਾ ਡੇਟਾ ਜੋੜਨ ਲਈ ਕਿਹਾ ਜਾਂਦਾ ਹੈ:

upd:{[tblName;data] // tblName нам не нужно, но обычно сервис обрабатывает несколько таблиц 
  tm:exec distinct time from data:() xkey preprocess data; // preprocess & calc time
  updMinute[data] each tm; // добавим данные для каждой минуты
};
updMinute:{[data;tm]
  if[tm<>currTime; roll tm; currTime::tm]; // поменяем минуту, если необходимо
  data:select from data where time=tm; // фильтрация
  if[count msyms:syms where not (syms:data`sym)in currSyms; addSyms msyms]; // новые символы
  updateAgg[`tradeAgg;offset+currSyms?syms;data]; // обновим агрегированную таблицу. Функция ? ищет индекс элементов списка справа в списке слева.
 };

ਇਹ ਸਭ ਹੈ. ਇੱਥੇ ਸਾਡੀ ਸੇਵਾ ਦਾ ਪੂਰਾ ਕੋਡ ਹੈ, ਜਿਵੇਂ ਕਿ ਵਾਅਦਾ ਕੀਤਾ ਗਿਆ ਸੀ, ਕੁਝ ਲਾਈਨਾਂ:

initWith:`sym`time`high`low`firstPrice`lastPrice`firstSize`lastSize`numTrades`volume`pvolume`turnover`avgPrice`avgSize`vwap`cumVolume!(`;00:00;0n;0n;0n;0n;0N;0N;0;0;0.0;0.0;0n;0n;0n;0);
aggCols:reverse key[initWith] except `sym`time;
rollColumns:`sym`cumVolume;

accumulatorCols:`numTrades`volume`pvolume`turnover;
specialCols:`high`low`firstPrice`firstSize;

selExpression:`high`low`firstPrice`lastPrice`firstSize`lastSize`numTrades`volume`pvolume`turnover!parse each ("max price";"min price";"first price";"last price";"first size";"last size";"count i";"sum size";"sum price";"sum price*size");
preprocess:?[;();`sym`time!`sym`time.minute;selExpression];

aggExpression:`high`low`firstPrice`lastPrice`firstSize`lastSize`avgPrice`avgSize`vwap`cumVolume!("row[`high]|inp`high";"row[`low]&inp`low";"row`firstPrice";"inp`lastPrice";"row`firstSize";"inp`lastSize";"pvolume%numTrades";"volume%numTrades";"turnover%volume";"row[`cumVolume]+inp`volume");
@[`aggExpression;specialCols;{"?[isFirst;inp`",y,";",x,"]"};string specialCols];
aggExpression[accumulatorCols]:{"row[`",x,"]+inp`",x } each string accumulatorCols;
updateAgg:value "{[aggTable;idx;inp] row:aggTable idx; isFirst_0=row`numTrades; .[aggTable;;:;]'[(idx;)each aggCols;(",(";"sv string[aggCols],'":",/:aggExpression aggCols),")]}"; / '

init:{
  tradeAgg::0#enlist[initWith];
  currTime::00:00;
  currSyms::`u#`symbol$();
  offset::0;
  rollCache:: `sym xkey update `u#sym from rollColumns#tradeAgg;
 };
roll:{[tm]
  if[currTime>tm; :init[]];
  rollCache,::offset _ rollColumns#tradeAgg;
  offset::count tradeAgg;
  currSyms::`u#`$();
 };
addSyms:{[syms]
  currSyms,::syms;
  `tradeAgg upsert @[count[syms]#enlist initWith;`sym`time,cols rc;:;(syms;currTime),(initWith cols rc)^value flip rc:rollCache ([] sym: syms)];
 };

upd:{[tblName;data] updMinute[data] each exec distinct time from data:() xkey preprocess data};
updMinute:{[data;tm]
  if[tm<>currTime; roll tm; currTime::tm];
  data:select from data where time=tm;
  if[count msyms:syms where not (syms:data`sym)in currSyms; addSyms msyms];
  updateAgg[`tradeAgg;offset+currSyms?syms;data];
 };

ਟੈਸਟਿੰਗ

ਆਓ ਸੇਵਾ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਦੀ ਜਾਂਚ ਕਰੀਏ. ਅਜਿਹਾ ਕਰਨ ਲਈ, ਚਲੋ ਇਸਨੂੰ ਇੱਕ ਵੱਖਰੀ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਚਲਾਓ (ਕੋਡ ਨੂੰ service.q ਫਾਈਲ ਵਿੱਚ ਪਾਓ) ਅਤੇ init ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰੋ:

q service.q –p 5566

q)init[]

ਕਿਸੇ ਹੋਰ ਕੰਸੋਲ ਵਿੱਚ, ਦੂਜੀ Q ਪ੍ਰਕਿਰਿਆ ਸ਼ੁਰੂ ਕਰੋ ਅਤੇ ਪਹਿਲੇ ਨਾਲ ਜੁੜੋ:

h:hopen `:host:5566
h:hopen 5566 // если оба на одном хосте

ਪਹਿਲਾਂ, ਆਓ ਚਿੰਨ੍ਹਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਬਣਾਈਏ - 10000 ਟੁਕੜੇ ਅਤੇ ਇੱਕ ਬੇਤਰਤੀਬ ਸਾਰਣੀ ਬਣਾਉਣ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਜੋੜੀਏ। ਦੂਜੇ ਕੰਸੋਲ ਵਿੱਚ:

syms:`IBM`AAPL`GOOG,-9997?`8
rnd:{[n;t] ([] sym:n?syms; time:t+asc n#til 25; price:n?10f; size:n?10)}

ਸਾਰਣੀ ਵਿੱਚ ਉਹਨਾਂ ਨੂੰ ਲੱਭਣਾ ਆਸਾਨ ਬਣਾਉਣ ਲਈ ਮੈਂ ਸੂਚੀ ਵਿੱਚ ਤਿੰਨ ਅਸਲੀ ਚਿੰਨ੍ਹ ਸ਼ਾਮਲ ਕੀਤੇ ਹਨ। rnd ਫੰਕਸ਼ਨ n ਕਤਾਰਾਂ ਦੇ ਨਾਲ ਇੱਕ ਬੇਤਰਤੀਬ ਸਾਰਣੀ ਬਣਾਉਂਦਾ ਹੈ, ਜਿੱਥੇ ਸਮਾਂ t ਤੋਂ t+25 ਮਿਲੀਸਕਿੰਟ ਤੱਕ ਬਦਲਦਾ ਹੈ।

ਹੁਣ ਤੁਸੀਂ ਸੇਵਾ ਨੂੰ ਡੇਟਾ ਭੇਜਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਸਕਦੇ ਹੋ (ਪਹਿਲੇ ਦਸ ਘੰਟੇ ਜੋੜੋ):

{h (`upd;`trade;rnd[10000;x])} each `time$00:00 + til 60*10

ਤੁਸੀਂ ਸੇਵਾ ਵਿੱਚ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਸਾਰਣੀ ਨੂੰ ਅੱਪਡੇਟ ਕੀਤਾ ਗਿਆ ਹੈ:

c 25 200
select from tradeAgg where sym=`AAPL
-20#select from tradeAgg where sym=`AAPL

ਨਤੀਜਾ:

sym|time|high|low|firstPrice|lastPrice|firstSize|lastSize|numTrades|volume|pvolume|turnover|avgPrice|avgSize|vwap|cumVolume
--|--|--|--|--|--------------------------------
AAPL|09:27|9.258904|9.258904|9.258904|9.258904|8|8|1|8|9.258904|74.07123|9.258904|8|9.258904|2888
AAPL|09:28|9.068162|9.068162|9.068162|9.068162|7|7|1|7|9.068162|63.47713|9.068162|7|9.068162|2895
AAPL|09:31|4.680449|0.2011121|1.620827|0.2011121|1|5|4|14|9.569556|36.84342|2.392389|3.5|2.631673|2909
AAPL|09:33|2.812535|2.812535|2.812535|2.812535|6|6|1|6|2.812535|16.87521|2.812535|6|2.812535|2915
AAPL|09:34|5.099025|5.099025|5.099025|5.099025|4|4|1|4|5.099025|20.3961|5.099025|4|5.099025|2919

ਚਲੋ ਹੁਣ ਇਹ ਪਤਾ ਲਗਾਉਣ ਲਈ ਲੋਡ ਟੈਸਟਿੰਗ ਕਰੀਏ ਕਿ ਸੇਵਾ ਪ੍ਰਤੀ ਮਿੰਟ ਕਿੰਨੇ ਡੇਟਾ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰ ਸਕਦੀ ਹੈ। ਮੈਂ ਤੁਹਾਨੂੰ ਯਾਦ ਕਰਾਵਾਂਗਾ ਕਿ ਅਸੀਂ ਅੱਪਡੇਟ ਅੰਤਰਾਲ ਨੂੰ 25 ਮਿਲੀਸਕਿੰਟ 'ਤੇ ਸੈੱਟ ਕੀਤਾ ਹੈ। ਇਸ ਅਨੁਸਾਰ, ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਡੇਟਾ ਦੀ ਬੇਨਤੀ ਕਰਨ ਲਈ ਸਮਾਂ ਦੇਣ ਲਈ ਸੇਵਾ (ਔਸਤਨ) ਪ੍ਰਤੀ ਅਪਡੇਟ ਘੱਟੋ ਘੱਟ 20 ਮਿਲੀਸਕਿੰਟ ਵਿੱਚ ਫਿੱਟ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ। ਦੂਜੀ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ ਹੇਠਾਂ ਦਰਜ ਕਰੋ:

tm:10:00:00.000
stressTest:{[n] 1 string[tm]," "; times,::h ({st:.z.T; upd[`trade;x]; .z.T-st};rnd[n;tm]); tm+:25}
start:{[n] times::(); do[4800;stressTest[n]]; -1 " "; `min`avg`med`max!(min times;avg times;med times;max times)}

4800 ਦੋ ਮਿੰਟ ਹੈ। ਤੁਸੀਂ ਹਰ 1000 ਮਿਲੀਸਕਿੰਟ ਵਿੱਚ 25 ਕਤਾਰਾਂ ਲਈ ਪਹਿਲਾਂ ਚੱਲਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਸਕਦੇ ਹੋ:

start 1000

ਮੇਰੇ ਕੇਸ ਵਿੱਚ, ਨਤੀਜਾ ਪ੍ਰਤੀ ਅਪਡੇਟ ਕੁਝ ਮਿਲੀਸਕਿੰਟ ਦੇ ਆਸਪਾਸ ਹੈ. ਇਸ ਲਈ ਮੈਂ ਤੁਰੰਤ ਕਤਾਰਾਂ ਦੀ ਗਿਣਤੀ ਵਧਾ ਕੇ 10.000 ਕਰਾਂਗਾ:

start 10000

ਨਤੀਜਾ:

min| 00:00:00.004
avg| 9.191458
med| 9f
max| 00:00:00.030

ਦੁਬਾਰਾ ਫਿਰ, ਕੁਝ ਖਾਸ ਨਹੀਂ, ਪਰ ਇਹ 24 ਮਿਲੀਅਨ ਲਾਈਨਾਂ ਪ੍ਰਤੀ ਮਿੰਟ, 400 ਹਜ਼ਾਰ ਪ੍ਰਤੀ ਸਕਿੰਟ ਹੈ. 25 ਮਿਲੀਸਕਿੰਟ ਤੋਂ ਵੱਧ ਲਈ, ਅੱਪਡੇਟ ਸਿਰਫ਼ 5 ਵਾਰ ਹੌਲੀ ਹੋਇਆ, ਜ਼ਾਹਰ ਤੌਰ 'ਤੇ ਜਦੋਂ ਮਿੰਟ ਬਦਲਿਆ। ਆਓ 100.000 ਤੱਕ ਵਧੀਏ:

start 100000

ਨਤੀਜਾ:

min| 00:00:00.013
avg| 25.11083
med| 24f
max| 00:00:00.108
q)sum times
00:02:00.532

ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ, ਸੇਵਾ ਮੁਸ਼ਕਿਲ ਨਾਲ ਸਿੱਝ ਸਕਦੀ ਹੈ, ਪਰ ਫਿਰ ਵੀ ਇਹ ਚਲਦੀ ਰਹਿਣ ਦਾ ਪ੍ਰਬੰਧ ਕਰਦੀ ਹੈ. ਡਾਟਾ ਦੀ ਅਜਿਹੀ ਮਾਤਰਾ (240 ਮਿਲੀਅਨ ਕਤਾਰਾਂ ਪ੍ਰਤੀ ਮਿੰਟ) ਬਹੁਤ ਜ਼ਿਆਦਾ ਹੈ, ਅਜਿਹੇ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਸੇਵਾ ਦੇ ਕਈ ਕਲੋਨ (ਜਾਂ ਦਰਜਨਾਂ ਕਲੋਨ) ਨੂੰ ਲਾਂਚ ਕਰਨਾ ਆਮ ਗੱਲ ਹੈ, ਜਿਨ੍ਹਾਂ ਵਿੱਚੋਂ ਹਰ ਇੱਕ ਅੱਖਰਾਂ ਦੇ ਸਿਰਫ ਹਿੱਸੇ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਦਾ ਹੈ। ਫਿਰ ਵੀ, ਨਤੀਜਾ ਇੱਕ ਵਿਆਖਿਆ ਕੀਤੀ ਭਾਸ਼ਾ ਲਈ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਹੈ ਜੋ ਮੁੱਖ ਤੌਰ 'ਤੇ ਡੇਟਾ ਸਟੋਰੇਜ 'ਤੇ ਕੇਂਦ੍ਰਿਤ ਹੈ।

ਸਵਾਲ ਪੈਦਾ ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਸਮਾਂ ਹਰੇਕ ਅੱਪਡੇਟ ਦੇ ਆਕਾਰ ਦੇ ਨਾਲ ਗੈਰ-ਰੇਖਿਕ ਤੌਰ 'ਤੇ ਕਿਉਂ ਵਧਦਾ ਹੈ। ਕਾਰਨ ਇਹ ਹੈ ਕਿ ਸੁੰਗੜਨ ਵਾਲਾ ਫੰਕਸ਼ਨ ਅਸਲ ਵਿੱਚ ਇੱਕ ਸੀ ਫੰਕਸ਼ਨ ਹੈ, ਜੋ ਅੱਪਡੇਟ ਏਗ ਨਾਲੋਂ ਬਹੁਤ ਜ਼ਿਆਦਾ ਕੁਸ਼ਲ ਹੈ। ਇੱਕ ਨਿਸ਼ਚਿਤ ਅੱਪਡੇਟ ਆਕਾਰ (ਲਗਭਗ 10.000) ਤੋਂ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋਏ, ਅੱਪਡੇਟ ਏਗ ਆਪਣੀ ਸੀਮਾ ਤੱਕ ਪਹੁੰਚਦਾ ਹੈ ਅਤੇ ਫਿਰ ਇਸਦਾ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਸਮਾਂ ਅੱਪਡੇਟ ਆਕਾਰ 'ਤੇ ਨਿਰਭਰ ਨਹੀਂ ਕਰਦਾ ਹੈ। ਇਹ ਸ਼ੁਰੂਆਤੀ ਕਦਮ Q ਦੇ ਕਾਰਨ ਹੈ ਕਿ ਸੇਵਾ ਡੇਟਾ ਦੇ ਅਜਿਹੇ ਵਾਲੀਅਮ ਨੂੰ ਹਜ਼ਮ ਕਰਨ ਦੇ ਯੋਗ ਹੈ। ਇਹ ਉਜਾਗਰ ਕਰਦਾ ਹੈ ਕਿ ਵੱਡੇ ਡੇਟਾ ਦੇ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਸਹੀ ਐਲਗੋਰਿਦਮ ਦੀ ਚੋਣ ਕਰਨਾ ਕਿੰਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ। ਇੱਕ ਹੋਰ ਬਿੰਦੂ ਮੈਮੋਰੀ ਵਿੱਚ ਡਾਟਾ ਦੀ ਸਹੀ ਸਟੋਰੇਜ਼ ਹੈ. ਜੇਕਰ ਡੇਟਾ ਕਾਲਮ ਰੂਪ ਵਿੱਚ ਸਟੋਰ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਸੀ ਜਾਂ ਸਮੇਂ ਦੁਆਰਾ ਆਰਡਰ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਸੀ, ਤਾਂ ਅਸੀਂ ਇੱਕ TLB ਕੈਸ਼ ਮਿਸ - ਪ੍ਰੋਸੈਸਰ ਐਡਰੈੱਸ ਕੈਸ਼ ਵਿੱਚ ਮੈਮੋਰੀ ਪੇਜ ਐਡਰੈੱਸ ਦੀ ਅਣਹੋਂਦ ਵਰਗੀ ਚੀਜ਼ ਤੋਂ ਜਾਣੂ ਹੋ ਜਾਵਾਂਗੇ। ਕਿਸੇ ਪਤੇ ਦੀ ਖੋਜ ਕਰਨ ਵਿੱਚ ਅਸਫਲ ਹੋਣ 'ਤੇ ਲਗਭਗ 30 ਗੁਣਾ ਜ਼ਿਆਦਾ ਸਮਾਂ ਲੱਗਦਾ ਹੈ, ਅਤੇ ਜੇਕਰ ਡੇਟਾ ਖਿੰਡਿਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ ਕਈ ਵਾਰ ਸੇਵਾ ਨੂੰ ਹੌਲੀ ਕਰ ਸਕਦਾ ਹੈ।

ਸਿੱਟਾ

ਇਸ ਲੇਖ ਵਿੱਚ, ਮੈਂ ਦਿਖਾਇਆ ਹੈ ਕਿ KDB+ ਅਤੇ Q ਡੇਟਾਬੇਸ ਨਾ ਸਿਰਫ਼ ਵੱਡੇ ਡੇਟਾ ਨੂੰ ਸਟੋਰ ਕਰਨ ਅਤੇ ਇਸਨੂੰ ਚੋਣ ਦੁਆਰਾ ਆਸਾਨੀ ਨਾਲ ਐਕਸੈਸ ਕਰਨ ਲਈ ਢੁਕਵਾਂ ਹੈ, ਸਗੋਂ ਡੇਟਾ ਪ੍ਰੋਸੈਸਿੰਗ ਸੇਵਾਵਾਂ ਬਣਾਉਣ ਲਈ ਵੀ ਢੁਕਵਾਂ ਹੈ ਜੋ ਲੱਖਾਂ ਕਤਾਰਾਂ/ਗੀਗਾਬਾਈਟ ਡੇਟਾ ਨੂੰ ਹਜ਼ਮ ਕਰਨ ਦੇ ਸਮਰੱਥ ਹਨ. ਇੱਕ ਸਿੰਗਲ Q ਪ੍ਰਕਿਰਿਆ Q ਭਾਸ਼ਾ ਆਪਣੇ ਵੈਕਟਰ ਪ੍ਰਕਿਰਤੀ, ਬਿਲਟ-ਇਨ SQL ਡਾਇਲੈਕਟ ਇੰਟਰਪ੍ਰੇਟਰ ਅਤੇ ਲਾਇਬ੍ਰੇਰੀ ਫੰਕਸ਼ਨਾਂ ਦੇ ਇੱਕ ਬਹੁਤ ਸਫਲ ਸਮੂਹ ਦੇ ਕਾਰਨ ਡੇਟਾ ਪ੍ਰੋਸੈਸਿੰਗ ਨਾਲ ਸਬੰਧਤ ਐਲਗੋਰਿਦਮ ਦੇ ਬਹੁਤ ਹੀ ਸੰਖੇਪ ਅਤੇ ਕੁਸ਼ਲ ਲਾਗੂ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ।

ਮੈਂ ਨੋਟ ਕਰਾਂਗਾ ਕਿ ਉਪਰੋਕਤ ਸਿਰਫ ਉਸ ਦਾ ਹਿੱਸਾ ਹੈ ਜੋ ਕਿ Q ਕਰ ਸਕਦਾ ਹੈ, ਇਸ ਵਿੱਚ ਹੋਰ ਵਿਲੱਖਣ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵੀ ਹਨ. ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਬਹੁਤ ਹੀ ਸਧਾਰਨ IPC ਪ੍ਰੋਟੋਕੋਲ ਜੋ ਵਿਅਕਤੀਗਤ Q ਪ੍ਰਕਿਰਿਆਵਾਂ ਵਿਚਕਾਰ ਸੀਮਾ ਨੂੰ ਮਿਟਾ ਦਿੰਦਾ ਹੈ ਅਤੇ ਤੁਹਾਨੂੰ ਇਹਨਾਂ ਵਿੱਚੋਂ ਸੈਂਕੜੇ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਇੱਕ ਸਿੰਗਲ ਨੈਟਵਰਕ ਵਿੱਚ ਜੋੜਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਜੋ ਕਿ ਦੁਨੀਆ ਦੇ ਵੱਖ-ਵੱਖ ਹਿੱਸਿਆਂ ਵਿੱਚ ਦਰਜਨਾਂ ਸਰਵਰਾਂ 'ਤੇ ਸਥਿਤ ਹੋ ਸਕਦਾ ਹੈ।

ਸਰੋਤ: www.habr.com