Tarantool DBMS ਵਿੱਚ ਉੱਚ-ਪੱਧਰੀ ਪ੍ਰਤੀਕ੍ਰਿਤੀ

ਹੈਲੋ, ਮੈਂ DBMS ਲਈ ਐਪਲੀਕੇਸ਼ਨ ਬਣਾ ਰਿਹਾ/ਰਹੀ ਹਾਂ ਤਰੰਤੂਲ Mail.ru ਸਮੂਹ ਦੁਆਰਾ ਵਿਕਸਤ ਕੀਤਾ ਇੱਕ ਪਲੇਟਫਾਰਮ ਹੈ ਜੋ ਇੱਕ ਉੱਚ-ਪ੍ਰਦਰਸ਼ਨ ਵਾਲੇ DBMS ਅਤੇ ਲੁਆ ਭਾਸ਼ਾ ਵਿੱਚ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਸਰਵਰ ਨੂੰ ਜੋੜਦਾ ਹੈ। ਟਾਰਨਟੂਲ 'ਤੇ ਅਧਾਰਤ ਹੱਲਾਂ ਦੀ ਉੱਚ ਗਤੀ ਪ੍ਰਾਪਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ, DBMS ਦੇ ਇਨ-ਮੈਮੋਰੀ ਮੋਡ ਲਈ ਸਮਰਥਨ ਅਤੇ ਡੇਟਾ ਦੇ ਨਾਲ ਇੱਕ ਸਿੰਗਲ ਐਡਰੈੱਸ ਸਪੇਸ ਵਿੱਚ ਐਪਲੀਕੇਸ਼ਨ ਕਾਰੋਬਾਰੀ ਤਰਕ ਨੂੰ ਚਲਾਉਣ ਦੀ ਯੋਗਤਾ ਦੇ ਕਾਰਨ। ਉਸੇ ਸਮੇਂ, ACID ਟ੍ਰਾਂਜੈਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਡੇਟਾ ਸਥਿਰਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਇਆ ਜਾਂਦਾ ਹੈ (ਇੱਕ WAL ਲੌਗ ਡਿਸਕ ਤੇ ਬਣਾਈ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ)। ਤਰਨਟੂਲ ਵਿੱਚ ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਅਤੇ ਸ਼ਾਰਡਿੰਗ ਲਈ ਬਿਲਟ-ਇਨ ਸਮਰਥਨ ਹੈ। ਸੰਸਕਰਣ 2.1 ਤੋਂ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋਏ, SQL ਭਾਸ਼ਾ ਵਿੱਚ ਸਵਾਲ ਸਮਰਥਿਤ ਹਨ। Tarantool ਓਪਨ ਸੋਰਸ ਹੈ ਅਤੇ ਸਧਾਰਨ BSD ਲਾਇਸੰਸ ਦੇ ਅਧੀਨ ਲਾਇਸੰਸਸ਼ੁਦਾ ਹੈ। ਇੱਕ ਵਪਾਰਕ ਐਂਟਰਪ੍ਰਾਈਜ਼ ਸੰਸਕਰਣ ਵੀ ਹੈ.

ਸ਼ਕਤੀ ਮਹਿਸੂਸ ਕਰੋ! (…ਉਰਫ਼ ਪ੍ਰਦਰਸ਼ਨ ਦਾ ਆਨੰਦ ਮਾਣੋ)

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

ਜਿਵੇਂ ਕਿ ਉੱਪਰ ਦੱਸਿਆ ਗਿਆ ਹੈ, Tarantool ਵਿੱਚ ਬਿਲਟ-ਇਨ ਡਾਟਾ ਰੀਪਲੀਕੇਸ਼ਨ ਹੈ। ਇਸਦੇ ਸੰਚਾਲਨ ਦਾ ਸਿਧਾਂਤ ਮਾਸਟਰ ਲੌਗ (WAL) ਵਿੱਚ ਸ਼ਾਮਲ ਸਾਰੇ ਲੈਣ-ਦੇਣਾਂ ਨੂੰ ਕ੍ਰਮਵਾਰ ਪ੍ਰਤੀਕ੍ਰਿਤੀਆਂ 'ਤੇ ਚਲਾਉਣਾ ਹੈ। ਆਮ ਤੌਰ 'ਤੇ ਅਜਿਹੀ ਪ੍ਰਤੀਕ੍ਰਿਤੀ (ਅਸੀਂ ਇਸਨੂੰ ਅੱਗੇ ਕਹਾਂਗੇ ਘੱਟ-ਪੱਧਰ) ਦੀ ਵਰਤੋਂ ਐਪਲੀਕੇਸ਼ਨ ਫਾਲਟ ਸਹਿਣਸ਼ੀਲਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਅਤੇ/ਜਾਂ ਕਲੱਸਟਰ ਨੋਡਾਂ ਵਿਚਕਾਰ ਰੀਡਿੰਗ ਲੋਡ ਨੂੰ ਵੰਡਣ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।

ਚੌਲ. 1. ਕਲੱਸਟਰ ਦੇ ਅੰਦਰ ਪ੍ਰਤੀਕ੍ਰਿਤੀ

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

1. ਟ੍ਰੈਫਿਕ ਬੱਚਤ:

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

2. HTTP ਐਕਸਚੇਂਜ ਨੂੰ ਲਾਗੂ ਕਰਨ ਵਿੱਚ ਕੋਈ ਮੁਸ਼ਕਲ ਨਹੀਂ ਹੈ, ਜੋ ਤੁਹਾਨੂੰ ਰਿਮੋਟ ਡੇਟਾਬੇਸ ਨੂੰ ਸਿੰਕ੍ਰੋਨਾਈਜ਼ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ।

ਚੌਲ. 2. HTTP ਉੱਤੇ ਪ੍ਰਤੀਕ੍ਰਿਤੀ

3. ਡੇਟਾਬੇਸ ਬਣਤਰਾਂ ਜਿਨ੍ਹਾਂ ਦੇ ਵਿਚਕਾਰ ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਇੱਕੋ ਜਿਹਾ ਨਹੀਂ ਹੋਣਾ ਚਾਹੀਦਾ (ਇਸ ਤੋਂ ਇਲਾਵਾ, ਆਮ ਸਥਿਤੀ ਵਿੱਚ, ਵੱਖ-ਵੱਖ DBMS, ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ, ਪਲੇਟਫਾਰਮਾਂ, ਆਦਿ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਵੀ ਸੰਭਵ ਹੈ)।

ਚੌਲ. 3. ਵਿਪਰੀਤ ਪ੍ਰਣਾਲੀਆਂ ਵਿੱਚ ਪ੍ਰਤੀਕ੍ਰਿਤੀ

ਨਨੁਕਸਾਨ ਇਹ ਹੈ ਕਿ, ਔਸਤਨ, ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਕੌਂਫਿਗਰੇਸ਼ਨ ਨਾਲੋਂ ਵਧੇਰੇ ਮੁਸ਼ਕਲ/ਮਹਿੰਗੀ ਹੈ, ਅਤੇ ਬਿਲਟ-ਇਨ ਕਾਰਜਕੁਸ਼ਲਤਾ ਨੂੰ ਅਨੁਕੂਲਿਤ ਕਰਨ ਦੀ ਬਜਾਏ, ਤੁਹਾਨੂੰ ਆਪਣੀ ਖੁਦ ਦੀ ਲਾਗੂ ਕਰਨੀ ਪਵੇਗੀ।

ਜੇਕਰ ਤੁਹਾਡੀ ਸਥਿਤੀ ਵਿੱਚ ਉਪਰੋਕਤ ਫਾਇਦੇ ਮਹੱਤਵਪੂਰਨ ਹਨ (ਜਾਂ ਇੱਕ ਜ਼ਰੂਰੀ ਸ਼ਰਤ ਹੈ), ਤਾਂ ਇਹ ਉੱਚ-ਪੱਧਰੀ ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਸਮਝਦਾਰ ਹੈ। ਆਉ Tarantool DBMS ਵਿੱਚ ਉੱਚ-ਪੱਧਰੀ ਡਾਟਾ ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੇ ਕਈ ਤਰੀਕਿਆਂ ਨੂੰ ਵੇਖੀਏ।

ਟ੍ਰੈਫਿਕ ਘੱਟ ਤੋਂ ਘੱਟ ਕਰਨਾ

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

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

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

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

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

ਉੱਚ-ਪੱਧਰੀ ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਦੇ ਫਰੇਮਵਰਕ ਦੇ ਅੰਦਰ ਟ੍ਰਾਂਸਫਰ ਕੀਤੇ ਗਏ ਡੇਟਾ ਦੀ ਮਾਤਰਾ ਨੂੰ ਘਟਾਉਣ ਦਾ ਆਖਰੀ ਪ੍ਰਸਤਾਵਿਤ ਤਰੀਕਾ ਮੈਨੂੰ ਸਭ ਤੋਂ ਅਨੁਕੂਲ ਅਤੇ ਸਰਵ ਵਿਆਪਕ ਜਾਪਦਾ ਹੈ. ਆਉ ਇਸ ਨੂੰ ਹੋਰ ਵਿਸਥਾਰ ਵਿੱਚ ਵੇਖੀਏ.

ਇੱਕ ਕਤਾਰ ਸੰਸਕਰਣ ਕਾਊਂਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਡੇਟਾ ਪਾਸ ਕਰਨਾ

ਸਰਵਰ/ਮਾਸਟਰ ਭਾਗ ਨੂੰ ਲਾਗੂ ਕਰਨਾ

MS SQL ਸਰਵਰ ਵਿੱਚ, ਇਸ ਪਹੁੰਚ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਕਾਲਮ ਕਿਸਮ ਹੈ - rowversion. ਹਰੇਕ ਡੇਟਾਬੇਸ ਵਿੱਚ ਇੱਕ ਕਾਊਂਟਰ ਹੁੰਦਾ ਹੈ ਜੋ ਹਰ ਵਾਰ ਇੱਕ ਰਿਕਾਰਡ ਨੂੰ ਇੱਕ ਸਾਰਣੀ ਵਿੱਚ ਜੋੜਿਆ/ਬਦਲਣ 'ਤੇ ਵਧਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਇੱਕ ਕਾਲਮ ਹੁੰਦਾ ਹੈ rowversion. ਇਸ ਕਾਊਂਟਰ ਦਾ ਮੁੱਲ ਆਪਣੇ ਆਪ ਹੀ ਜੋੜਿਆ/ਬਦਲਿਆ ਰਿਕਾਰਡ ਵਿੱਚ ਇਸ ਕਾਲਮ ਦੇ ਖੇਤਰ ਨੂੰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। Tarantool DBMS ਵਿੱਚ ਸਮਾਨ ਬਿਲਟ-ਇਨ ਵਿਧੀ ਨਹੀਂ ਹੈ। ਹਾਲਾਂਕਿ, ਤਰਨਟੂਲ ਵਿੱਚ ਇਸਨੂੰ ਹੱਥੀਂ ਲਾਗੂ ਕਰਨਾ ਮੁਸ਼ਕਲ ਨਹੀਂ ਹੈ. ਆਓ ਦੇਖੀਏ ਕਿ ਇਹ ਕਿਵੇਂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ.

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

Tarantool ਵਿੱਚ ਕੋਈ ਵੀ ਡਾਟਾਬੇਸ ਕਾਰਵਾਈ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਤੁਹਾਨੂੰ ਹੇਠ ਲਿਖੀ ਕਮਾਂਡ ਚਲਾਉਣ ਦੀ ਲੋੜ ਹੈ:

box.cfg{}

ਨਤੀਜੇ ਵਜੋਂ, Tarantool ਮੌਜੂਦਾ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਡੇਟਾਬੇਸ ਸਨੈਪਸ਼ਾਟ ਅਤੇ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਲੌਗ ਲਿਖਣਾ ਸ਼ੁਰੂ ਕਰ ਦੇਵੇਗਾ।

ਆਉ ਇੱਕ ਕ੍ਰਮ ਬਣਾਉ row_version:

box.schema.sequence.create('row_version',
    { if_not_exists = true })

ਵਿਕਲਪ if_not_exists ਰਚਨਾ ਸਕ੍ਰਿਪਟ ਨੂੰ ਕਈ ਵਾਰ ਚਲਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ: ਜੇਕਰ ਆਬਜੈਕਟ ਮੌਜੂਦ ਹੈ, ਤਾਂ Tarantool ਇਸਨੂੰ ਦੁਬਾਰਾ ਬਣਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਨਹੀਂ ਕਰੇਗਾ। ਇਹ ਵਿਕਲਪ ਸਾਰੀਆਂ ਅਗਲੀਆਂ DDL ਕਮਾਂਡਾਂ ਵਿੱਚ ਵਰਤਿਆ ਜਾਵੇਗਾ।

ਆਉ ਇੱਕ ਉਦਾਹਰਨ ਦੇ ਤੌਰ ਤੇ ਇੱਕ ਸਪੇਸ ਬਣਾਈਏ।

box.schema.space.create('goods', {
    format = {
        {
            name = 'id',
            type = 'unsigned'

        },
        {
            name = 'name',
            type = 'string'

        },
        {
            name = 'code',
            type = 'unsigned'

        },
        {
            name = 'row_ver',
            type = 'unsigned'

        }
    },
    if_not_exists = true
})

ਇੱਥੇ ਅਸੀਂ ਸਪੇਸ ਦਾ ਨਾਮ ਸੈੱਟ ਕਰਦੇ ਹਾਂ (goods), ਖੇਤਰ ਦੇ ਨਾਮ ਅਤੇ ਉਹਨਾਂ ਦੀਆਂ ਕਿਸਮਾਂ।

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

box.schema.sequence.create('goods_id',
    { if_not_exists = true })
box.space.goods:create_index('primary', {
    parts = { 'id' },
    sequence = 'goods_id',
    unique = true,
    type = 'HASH',
    if_not_exists = true
})

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

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

box.space.goods:before_replace(function(old, new)
    return box.tuple.new({new[1], new[2], new[3],
        box.sequence.row_version:next()})
end)

ਹੇਠਾਂ ਦਿੱਤਾ ਟਰਿੱਗਰ ਖੇਤਰ ਮੁੱਲ ਨੂੰ ਬਦਲਦਾ ਹੈ row_ver ਕ੍ਰਮ ਦੇ ਅਗਲੇ ਮੁੱਲ ਤੱਕ ਸਟੋਰ ਕੀਤਾ tuple row_version.

ਸਪੇਸ ਤੋਂ ਡੇਟਾ ਐਕਸਟਰੈਕਟ ਕਰਨ ਦੇ ਯੋਗ ਹੋਣ ਲਈ goods ਕਾਲਮ ਦੁਆਰਾ row_ver, ਆਓ ਇੱਕ ਸੂਚਕਾਂਕ ਬਣਾਈਏ:

box.space.goods:create_index('row_ver', {
    parts = { 'row_ver' },
    unique = true,
    type = 'TREE',
    if_not_exists = true
})

ਸੂਚਕਾਂਕ ਕਿਸਮ - ਰੁੱਖ (TREE), ਕਿਉਂਕਿ ਸਾਨੂੰ ਕਾਲਮ ਵਿੱਚ ਮੁੱਲਾਂ ਦੇ ਵਧਦੇ ਕ੍ਰਮ ਵਿੱਚ ਡੇਟਾ ਨੂੰ ਐਕਸਟਰੈਕਟ ਕਰਨ ਦੀ ਲੋੜ ਹੋਵੇਗੀ row_ver.

ਆਉ ਸਪੇਸ ਵਿੱਚ ਕੁਝ ਡੇਟਾ ਜੋੜੀਏ:

box.space.goods:insert{nil, 'pen', 123}
box.space.goods:insert{nil, 'pencil', 321}
box.space.goods:insert{nil, 'brush', 100}
box.space.goods:insert{nil, 'watercolour', 456}
box.space.goods:insert{nil, 'album', 101}
box.space.goods:insert{nil, 'notebook', 800}
box.space.goods:insert{nil, 'rubber', 531}
box.space.goods:insert{nil, 'ruler', 135}

ਕਿਉਂਕਿ ਪਹਿਲਾ ਫੀਲਡ ਇੱਕ ਆਟੋ-ਇਨਕਰੀਮੈਂਟ ਕਾਊਂਟਰ ਹੈ; ਅਸੀਂ ਇਸਦੀ ਬਜਾਏ nil ਪਾਸ ਕਰਦੇ ਹਾਂ। Tarantool ਆਪਣੇ ਆਪ ਹੀ ਅਗਲੇ ਮੁੱਲ ਨੂੰ ਬਦਲ ਦੇਵੇਗਾ। ਇਸੇ ਤਰ੍ਹਾਂ, ਕਾਲਮ ਖੇਤਰਾਂ ਦੇ ਮੁੱਲ ਦੇ ਰੂਪ ਵਿੱਚ row_ver ਤੁਸੀਂ nil ਪਾਸ ਕਰ ਸਕਦੇ ਹੋ - ਜਾਂ ਮੁੱਲ ਨੂੰ ਬਿਲਕੁਲ ਨਹੀਂ ਦੱਸ ਸਕਦੇ, ਕਿਉਂਕਿ ਇਹ ਕਾਲਮ ਸਪੇਸ ਵਿੱਚ ਆਖਰੀ ਸਥਾਨ ਰੱਖਦਾ ਹੈ।

ਆਉ ਸੰਮਿਲਨ ਦੇ ਨਤੀਜੇ ਦੀ ਜਾਂਚ ਕਰੀਏ:

tarantool> box.space.goods:select()
---
- - [1, 'pen', 123, 1]
  - [2, 'pencil', 321, 2]
  - [3, 'brush', 100, 3]
  - [4, 'watercolour', 456, 4]
  - [5, 'album', 101, 5]
  - [6, 'notebook', 800, 6]
  - [7, 'rubber', 531, 7]
  - [8, 'ruler', 135, 8]
...

ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਵੇਖ ਸਕਦੇ ਹੋ, ਪਹਿਲੇ ਅਤੇ ਆਖਰੀ ਖੇਤਰ ਆਟੋਮੈਟਿਕਲੀ ਭਰੇ ਜਾਂਦੇ ਹਨ. ਹੁਣ ਸਪੇਸ ਬਦਲਾਅ ਦੇ ਪੰਨੇ-ਦਰ-ਪੰਨੇ ਅੱਪਲੋਡ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨ ਲਿਖਣਾ ਆਸਾਨ ਹੋ ਜਾਵੇਗਾ goods:

local page_size = 5
local function get_goods(row_ver)
    local index = box.space.goods.index.row_ver
    local goods = {}
    local counter = 0
    for _, tuple in index:pairs(row_ver, {
        iterator = 'GT' }) do
        local obj = tuple:tomap({ names_only = true })
        table.insert(goods, obj)
        counter = counter + 1
        if counter >= page_size then
            break
        end
    end
    return goods
end

ਫੰਕਸ਼ਨ ਮੁੱਲ ਨੂੰ ਪੈਰਾਮੀਟਰ ਵਜੋਂ ਲੈਂਦਾ ਹੈ row_ver, ਜਿਸ ਤੋਂ ਬਦਲਾਵ ਨੂੰ ਅਨਲੋਡ ਕਰਨਾ ਜ਼ਰੂਰੀ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਬਦਲੇ ਹੋਏ ਡੇਟਾ ਦਾ ਇੱਕ ਹਿੱਸਾ ਵਾਪਸ ਕਰਦਾ ਹੈ।

ਤਰਨਟੂਲ ਵਿੱਚ ਡੇਟਾ ਸੈਂਪਲਿੰਗ ਸੂਚਕਾਂਕ ਦੁਆਰਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਫੰਕਸ਼ਨ get_goods ਸੂਚਕਾਂਕ ਦੁਆਰਾ ਇੱਕ ਇਟਰੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ row_ver ਬਦਲਿਆ ਡਾਟਾ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ. ਇਟਰੇਟਰ ਦੀ ਕਿਸਮ GT (ਇਸ ਤੋਂ ਵੱਧ, ਇਸ ਤੋਂ ਵੱਧ) ਹੈ। ਇਸਦਾ ਮਤਲਬ ਇਹ ਹੈ ਕਿ ਦੁਹਰਾਓ ਕ੍ਰਮਵਾਰ ਪਾਸ ਕੀਤੀ ਕੁੰਜੀ (ਫੀਲਡ ਮੁੱਲ) ਤੋਂ ਸ਼ੁਰੂ ਹੋਣ ਵਾਲੇ ਸੂਚਕਾਂਕ ਮੁੱਲਾਂ ਨੂੰ ਪਾਰ ਕਰੇਗਾ row_ver).

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

local function unflatten_goods(tuple)
    local obj = {}
    obj.id = tuple.id
    obj.goods_name = tuple.name
    obj.comment = 'some comment'
    obj.row_ver = tuple.row_ver
    return obj
end

ਆਉਟਪੁੱਟ ਡੇਟਾ ਦਾ ਪੰਨਾ ਆਕਾਰ (ਇੱਕ ਹਿੱਸੇ ਵਿੱਚ ਰਿਕਾਰਡਾਂ ਦੀ ਗਿਣਤੀ) ਵੇਰੀਏਬਲ ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ page_size. ਉਦਾਹਰਨ ਵਿੱਚ ਮੁੱਲ page_size 5 ਹੈ. ਇੱਕ ਅਸਲ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ, ਪੰਨੇ ਦਾ ਆਕਾਰ ਆਮ ਤੌਰ 'ਤੇ ਵਧੇਰੇ ਮਹੱਤਵਪੂਰਨ ਹੁੰਦਾ ਹੈ। ਇਹ ਸਪੇਸ ਟੂਪਲ ਦੇ ਔਸਤ ਆਕਾਰ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। ਅਨੁਕੂਲ ਪੰਨੇ ਦਾ ਆਕਾਰ ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ ਸਮੇਂ ਨੂੰ ਮਾਪ ਕੇ ਅਨੁਭਵੀ ਤੌਰ 'ਤੇ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਪੰਨੇ ਦਾ ਆਕਾਰ ਜਿੰਨਾ ਵੱਡਾ ਹੋਵੇਗਾ, ਭੇਜਣ ਅਤੇ ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲੇ ਪਾਸਿਆਂ ਦੇ ਵਿਚਕਾਰ ਰਾਊਂਡਟਰਿਪ ਦੀ ਗਿਣਤੀ ਓਨੀ ਹੀ ਘੱਟ ਹੋਵੇਗੀ। ਇਸ ਤਰ੍ਹਾਂ ਤੁਸੀਂ ਤਬਦੀਲੀਆਂ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰਨ ਲਈ ਸਮੁੱਚਾ ਸਮਾਂ ਘਟਾ ਸਕਦੇ ਹੋ। ਹਾਲਾਂਕਿ, ਜੇਕਰ ਪੰਨੇ ਦਾ ਆਕਾਰ ਬਹੁਤ ਵੱਡਾ ਹੈ, ਤਾਂ ਅਸੀਂ ਨਮੂਨੇ ਨੂੰ ਸੀਰੀਅਲ ਕਰਨ ਲਈ ਸਰਵਰ 'ਤੇ ਬਹੁਤ ਲੰਮਾ ਸਮਾਂ ਬਿਤਾਵਾਂਗੇ। ਨਤੀਜੇ ਵਜੋਂ, ਸਰਵਰ 'ਤੇ ਆਉਣ ਵਾਲੀਆਂ ਹੋਰ ਬੇਨਤੀਆਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਵਿੱਚ ਦੇਰੀ ਹੋ ਸਕਦੀ ਹੈ। ਪੈਰਾਮੀਟਰ page_size ਸੰਰਚਨਾ ਫਾਇਲ ਤੋਂ ਲੋਡ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਹਰੇਕ ਪ੍ਰਸਾਰਿਤ ਸਪੇਸ ਲਈ, ਤੁਸੀਂ ਇਸਦਾ ਆਪਣਾ ਮੁੱਲ ਸੈੱਟ ਕਰ ਸਕਦੇ ਹੋ। ਹਾਲਾਂਕਿ, ਜ਼ਿਆਦਾਤਰ ਸਪੇਸ ਲਈ ਡਿਫਾਲਟ ਮੁੱਲ (ਉਦਾਹਰਨ ਲਈ, 100) ਢੁਕਵਾਂ ਹੋ ਸਕਦਾ ਹੈ।

ਆਉ ਫੰਕਸ਼ਨ ਨੂੰ ਐਗਜ਼ੀਕਿਊਟ ਕਰੀਏ get_goods:

tarantool> get_goods(0)

---
- - row_ver: 1
    code: 123
    name: pen
    id: 1
  - row_ver: 2
    code: 321
    name: pencil
    id: 2
  - row_ver: 3
    code: 100
    name: brush
    id: 3
  - row_ver: 4
    code: 456
    name: watercolour
    id: 4
  - row_ver: 5
    code: 101
    name: album
    id: 5
...

ਆਉ ਫੀਲਡ ਵੈਲਯੂ ਲੈਂਦੇ ਹਾਂ row_ver ਆਖਰੀ ਲਾਈਨ ਤੋਂ ਅਤੇ ਫੰਕਸ਼ਨ ਨੂੰ ਦੁਬਾਰਾ ਕਾਲ ਕਰੋ:

tarantool> get_goods(5)

---
- - row_ver: 6
    code: 800
    name: notebook
    id: 6
  - row_ver: 7
    code: 531
    name: rubber
    id: 7
  - row_ver: 8
    code: 135
    name: ruler
    id: 8
...

ਇੱਕ ਵਾਰ ਫਿਰ ਤੋਂ:

tarantool> get_goods(8)
---
- []
...

ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਵੇਖ ਸਕਦੇ ਹੋ, ਜਦੋਂ ਇਸ ਤਰੀਕੇ ਨਾਲ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਫੰਕਸ਼ਨ ਸਾਰੇ ਸਪੇਸ ਰਿਕਾਰਡਾਂ ਨੂੰ ਪੰਨੇ ਦੇ ਹਿਸਾਬ ਨਾਲ ਵਾਪਸ ਕਰਦਾ ਹੈ goods. ਆਖਰੀ ਪੰਨੇ ਤੋਂ ਬਾਅਦ ਇੱਕ ਖਾਲੀ ਚੋਣ ਹੈ।

ਆਉ ਸਪੇਸ ਵਿੱਚ ਬਦਲਾਅ ਕਰੀਏ:

box.space.goods:update(4, {{'=', 6, 'copybook'}})
box.space.goods:insert{nil, 'clip', 234}
box.space.goods:insert{nil, 'folder', 432}

ਅਸੀਂ ਖੇਤਰ ਮੁੱਲ ਬਦਲ ਦਿੱਤਾ ਹੈ name ਇੱਕ ਐਂਟਰੀ ਲਈ ਅਤੇ ਦੋ ਨਵੀਆਂ ਐਂਟਰੀਆਂ ਜੋੜੀਆਂ।

ਚਲੋ ਆਖਰੀ ਫੰਕਸ਼ਨ ਕਾਲ ਨੂੰ ਦੁਹਰਾਓ:

tarantool> get_goods(8)
---



- - row_ver: 9
    code: 800
    name: copybook
    id: 6
  - row_ver: 10
    code: 234
    name: clip
    id: 9
  - row_ver: 11
    code: 432
    name: folder
    id: 10
...

ਫੰਕਸ਼ਨ ਨੇ ਬਦਲਿਆ ਅਤੇ ਜੋੜਿਆ ਰਿਕਾਰਡ ਵਾਪਸ ਕਰ ਦਿੱਤਾ। ਇਸ ਲਈ ਫੰਕਸ਼ਨ get_goods ਤੁਹਾਨੂੰ ਡਾਟਾ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ ਜੋ ਇਸਦੀ ਪਿਛਲੀ ਕਾਲ ਤੋਂ ਬਦਲਿਆ ਹੈ, ਜੋ ਕਿ ਵਿਚਾਰ ਅਧੀਨ ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਵਿਧੀ ਦਾ ਆਧਾਰ ਹੈ।

ਅਸੀਂ ਇਸ ਲੇਖ ਦੇ ਦਾਇਰੇ ਤੋਂ ਬਾਹਰ JSON ਦੇ ਰੂਪ ਵਿੱਚ HTTP ਰਾਹੀਂ ਨਤੀਜੇ ਜਾਰੀ ਕਰਨ ਨੂੰ ਛੱਡ ਦੇਵਾਂਗੇ। ਤੁਸੀਂ ਇਸ ਬਾਰੇ ਇੱਥੇ ਪੜ੍ਹ ਸਕਦੇ ਹੋ: https://habr.com/ru/company/mailru/blog/272141/

ਕਲਾਇੰਟ/ਸਲੇਵ ਹਿੱਸੇ ਨੂੰ ਲਾਗੂ ਕਰਨਾ

ਆਓ ਦੇਖੀਏ ਕਿ ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲੇ ਪਾਸੇ ਦਾ ਲਾਗੂਕਰਨ ਕਿਹੋ ਜਿਹਾ ਦਿਸਦਾ ਹੈ। ਆਉ ਡਾਊਨਲੋਡ ਕੀਤੇ ਡੇਟਾ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲੇ ਪਾਸੇ ਇੱਕ ਥਾਂ ਬਣਾਈਏ:

box.schema.space.create('goods', {
    format = {
        {
            name = 'id',
            type = 'unsigned'

        },
        {
            name = 'name',
            type = 'string'

        },
        {
            name = 'code',
            type = 'unsigned'

        }
    },
    if_not_exists = true
})

box.space.goods:create_index('primary', {
    parts = { 'id' },
    sequence = 'goods_id',
    unique = true,
    type = 'HASH',
    if_not_exists = true
})

ਸਪੇਸ ਦੀ ਬਣਤਰ ਸਰੋਤ ਵਿੱਚ ਸਪੇਸ ਦੀ ਬਣਤਰ ਵਰਗੀ ਹੈ। ਪਰ ਕਿਉਂਕਿ ਅਸੀਂ ਪ੍ਰਾਪਤ ਕੀਤੇ ਡੇਟਾ ਨੂੰ ਹੋਰ ਕਿਤੇ ਵੀ ਪਾਸ ਨਹੀਂ ਕਰਨ ਜਾ ਰਹੇ ਹਾਂ, ਕਾਲਮ row_ver ਪ੍ਰਾਪਤਕਰਤਾ ਦੀ ਥਾਂ ਵਿੱਚ ਨਹੀਂ ਹੈ। ਖੇਤਰ ਵਿੱਚ id ਸਰੋਤ ਪਛਾਣਕਰਤਾਵਾਂ ਨੂੰ ਰਿਕਾਰਡ ਕੀਤਾ ਜਾਵੇਗਾ। ਇਸ ਲਈ, ਰਿਸੀਵਰ ਵਾਲੇ ਪਾਸੇ ਇਸ ਨੂੰ ਸਵੈ-ਵਧਾਉਣ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ ਹੈ.

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਸਾਨੂੰ ਮੁੱਲਾਂ ਨੂੰ ਬਚਾਉਣ ਲਈ ਇੱਕ ਥਾਂ ਦੀ ਲੋੜ ਹੈ row_ver:

box.schema.space.create('row_ver', {
    format = {
        {
            name = 'space_name',
            type = 'string'

        },
        {
            name = 'value',
            type = 'string'

        }
    },
    if_not_exists = true
})

box.space.row_ver:create_index('primary', {
    parts = { 'space_name' },
    unique = true,
    type = 'HASH',
    if_not_exists = true
})

ਹਰੇਕ ਲੋਡ ਕੀਤੀ ਥਾਂ ਲਈ (ਫੀਲਡ space_name) ਅਸੀਂ ਇੱਥੇ ਆਖਰੀ ਲੋਡ ਕੀਤੇ ਮੁੱਲ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰਾਂਗੇ row_ver (ਫੀਲਡ value). ਕਾਲਮ ਪ੍ਰਾਇਮਰੀ ਕੁੰਜੀ ਵਜੋਂ ਕੰਮ ਕਰਦਾ ਹੈ space_name.

ਆਉ ਸਪੇਸ ਡੇਟਾ ਲੋਡ ਕਰਨ ਲਈ ਇੱਕ ਫੰਕਸ਼ਨ ਬਣਾਈਏ goods HTTP ਦੁਆਰਾ. ਅਜਿਹਾ ਕਰਨ ਲਈ, ਸਾਨੂੰ ਇੱਕ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਲੋੜ ਹੈ ਜੋ ਇੱਕ HTTP ਕਲਾਇੰਟ ਨੂੰ ਲਾਗੂ ਕਰਦੀ ਹੈ। ਹੇਠ ਦਿੱਤੀ ਲਾਈਨ ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਲੋਡ ਕਰਦੀ ਹੈ ਅਤੇ HTTP ਕਲਾਇੰਟ ਨੂੰ ਚਾਲੂ ਕਰਦੀ ਹੈ:

local http_client = require('http.client').new()

ਸਾਨੂੰ json ਡੀਸੀਰੀਅਲਾਈਜ਼ੇਸ਼ਨ ਲਈ ਇੱਕ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵੀ ਲੋੜ ਹੈ:

local json = require('json')

ਇਹ ਇੱਕ ਡਾਟਾ ਲੋਡਿੰਗ ਫੰਕਸ਼ਨ ਬਣਾਉਣ ਲਈ ਕਾਫੀ ਹੈ:

local function load_data(url, row_ver)
    local url = ('%s?rowVer=%s'):format(url,
        tostring(row_ver))
    local body = nil
    local data = http_client:request('GET', url, body, {
        keepalive_idle =  1,
        keepalive_interval = 1
    })
    return json.decode(data.body)
end

ਫੰਕਸ਼ਨ url ਪਤੇ ਤੇ ਇੱਕ HTTP ਬੇਨਤੀ ਨੂੰ ਚਲਾਉਂਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਭੇਜਦਾ ਹੈ row_ver ਇੱਕ ਪੈਰਾਮੀਟਰ ਦੇ ਤੌਰ 'ਤੇ ਅਤੇ ਬੇਨਤੀ ਦਾ ਡੀਸੀਰੀਅਲਾਈਜ਼ਡ ਨਤੀਜਾ ਵਾਪਸ ਕਰਦਾ ਹੈ।

ਪ੍ਰਾਪਤ ਡੇਟਾ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ:

local function save_goods(goods)
    local n = #goods
    box.atomic(function()
        for i = 1, n do
            local obj = goods[i]
            box.space.goods:put(
                obj.id, obj.name, obj.code)
        end
    end)
end

ਸਪੇਸ ਵਿੱਚ ਡਾਟਾ ਬਚਾਉਣ ਦਾ ਚੱਕਰ goods ਇੱਕ ਲੈਣ-ਦੇਣ ਵਿੱਚ ਰੱਖਿਆ ਗਿਆ (ਇਸ ਲਈ ਫੰਕਸ਼ਨ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ box.atomic) ਡਿਸਕ ਓਪਰੇਸ਼ਨਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਣ ਲਈ.

ਅੰਤ ਵਿੱਚ, ਸਥਾਨਕ ਸਪੇਸ ਸਿੰਕ੍ਰੋਨਾਈਜ਼ੇਸ਼ਨ ਫੰਕਸ਼ਨ goods ਇੱਕ ਸਰੋਤ ਨਾਲ ਤੁਸੀਂ ਇਸਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕਰ ਸਕਦੇ ਹੋ:

local function sync_goods()
    local tuple = box.space.row_ver:get('goods')
    local row_ver = tuple and tuple.value or 0

    —— set your url here:
    local url = 'http://127.0.0.1:81/test/goods/list'

    while true do
        local goods = load_goods(url, row_ver)

        local count = #goods
        if count == 0 then
            return
        end

        save_goods(goods)

        row_ver = goods[count].rowVer
        box.space.row_ver:put({'goods', row_ver})
    end
end

ਪਹਿਲਾਂ ਅਸੀਂ ਪਹਿਲਾਂ ਸੇਵ ਕੀਤੇ ਮੁੱਲ ਨੂੰ ਪੜ੍ਹਦੇ ਹਾਂ row_ver ਸਪੇਸ ਲਈ goods. ਜੇਕਰ ਇਹ ਗੁੰਮ ਹੈ (ਪਹਿਲਾ ਐਕਸਚੇਂਜ ਸੈਸ਼ਨ), ਤਾਂ ਅਸੀਂ ਇਸਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਲੈਂਦੇ ਹਾਂ row_ver ਜ਼ੀਰੋ ਅੱਗੇ ਚੱਕਰ ਵਿੱਚ ਅਸੀਂ ਨਿਸ਼ਚਿਤ url 'ਤੇ ਸਰੋਤ ਤੋਂ ਬਦਲੇ ਗਏ ਡੇਟਾ ਦਾ ਪੰਨਾ-ਦਰ-ਪੰਨਾ ਡਾਊਨਲੋਡ ਕਰਦੇ ਹਾਂ। ਹਰੇਕ ਦੁਹਰਾਅ 'ਤੇ, ਅਸੀਂ ਪ੍ਰਾਪਤ ਕੀਤੇ ਡੇਟਾ ਨੂੰ ਉਚਿਤ ਸਥਾਨਕ ਸਪੇਸ ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਕਰਦੇ ਹਾਂ ਅਤੇ ਮੁੱਲ ਨੂੰ ਅਪਡੇਟ ਕਰਦੇ ਹਾਂ row_ver (ਸਪੇਸ ਵਿੱਚ row_ver ਅਤੇ ਵੇਰੀਏਬਲ ਵਿੱਚ row_ver) - ਮੁੱਲ ਲਵੋ row_ver ਲੋਡ ਕੀਤੇ ਡੇਟਾ ਦੀ ਆਖਰੀ ਲਾਈਨ ਤੋਂ।

ਦੁਰਘਟਨਾਤਮਕ ਲੂਪਿੰਗ (ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਇੱਕ ਗਲਤੀ ਦੇ ਮਾਮਲੇ ਵਿੱਚ) ਤੋਂ ਬਚਾਉਣ ਲਈ, ਲੂਪ while ਦੁਆਰਾ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ for:

for _ = 1, max_req do ...

ਫੰਕਸ਼ਨ ਨੂੰ ਚਲਾਉਣ ਦੇ ਨਤੀਜੇ ਵਜੋਂ sync_goods ਸਪੇਸ goods ਪ੍ਰਾਪਤਕਰਤਾ ਵਿੱਚ ਸਾਰੇ ਸਪੇਸ ਰਿਕਾਰਡਾਂ ਦੇ ਨਵੀਨਤਮ ਸੰਸਕਰਣ ਸ਼ਾਮਲ ਹੋਣਗੇ goods ਸਰੋਤ ਵਿੱਚ.

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

ਕ੍ਰਮ row_ver ਹੋਰ ਸਪੇਸ ਤੋਂ ਡੇਟਾ ਨੂੰ ਪ੍ਰਸਾਰਿਤ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ: ਹਰੇਕ ਪ੍ਰਸਾਰਿਤ ਸਪੇਸ ਲਈ ਇੱਕ ਵੱਖਰਾ ਕ੍ਰਮ ਬਣਾਉਣ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ ਹੈ।

ਅਸੀਂ Tarantool DBMS ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਉੱਚ-ਪੱਧਰੀ ਡਾਟਾ ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਦੇ ਇੱਕ ਪ੍ਰਭਾਵੀ ਤਰੀਕੇ ਨੂੰ ਦੇਖਿਆ।

ਸਿੱਟਾ

1. Tarantool DBMS ਉੱਚ-ਲੋਡ ਐਪਲੀਕੇਸ਼ਨਾਂ ਬਣਾਉਣ ਲਈ ਇੱਕ ਆਕਰਸ਼ਕ, ਵਾਅਦਾ ਕਰਨ ਵਾਲਾ ਉਤਪਾਦ ਹੈ।
2. ਉੱਚ-ਪੱਧਰੀ ਡਾਟਾ ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਦੇ ਹੇਠਲੇ-ਪੱਧਰ ਦੀ ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਨਾਲੋਂ ਬਹੁਤ ਸਾਰੇ ਫਾਇਦੇ ਹਨ।
3. ਲੇਖ ਵਿੱਚ ਚਰਚਾ ਕੀਤੀ ਗਈ ਉੱਚ-ਪੱਧਰੀ ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਵਿਧੀ ਤੁਹਾਨੂੰ ਸਿਰਫ਼ ਉਹਨਾਂ ਰਿਕਾਰਡਾਂ ਨੂੰ ਟ੍ਰਾਂਸਫਰ ਕਰਕੇ ਟ੍ਰਾਂਸਫਰ ਕੀਤੇ ਡੇਟਾ ਦੀ ਮਾਤਰਾ ਨੂੰ ਘੱਟ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀ ਹੈ ਜੋ ਪਿਛਲੇ ਐਕਸਚੇਂਜ ਸੈਸ਼ਨ ਤੋਂ ਬਾਅਦ ਬਦਲ ਗਏ ਹਨ।

ਸਰੋਤ: www.habr.com