ਇੰਟਰਸਿਸਟਮ IRIS ਗਲੋਬਲ ਵਿੱਚ ਲੈਣ-ਦੇਣ

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

ਲੇਖਾਂ ਦੀ ਲੜੀ ਵਿੱਚ ਗਲੋਬਲਜ਼ ਬਾਰੇ ਹੋਰ ਪੜ੍ਹੋ “ਗਲੋਬਲ ਡੇਟਾ ਸਟੋਰ ਕਰਨ ਲਈ ਖਜ਼ਾਨਾ-ਤਲਵਾਰਾਂ ਹਨ”:

ਰੁੱਖ. ਭਾਗ 1
ਰੁੱਖ. ਭਾਗ 2
ਸਪਾਰਸ ਐਰੇ। ਭਾਗ 3

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

ਜਿਵੇਂ ਕਿ ਰਿਲੇਸ਼ਨਲ ਡੇਟਾਬੇਸ ਦੀ ਥਿਊਰੀ ਤੋਂ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ, ਲੈਣ-ਦੇਣ ਦੇ ਇੱਕ ਚੰਗੇ ਅਮਲ ਨੂੰ ਲੋੜਾਂ ਨੂੰ ਪੂਰਾ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ ACID:

A - ਪਰਮਾਣੂ (ਪਰਮਾਣੂ). ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਵਿੱਚ ਕੀਤੀਆਂ ਸਾਰੀਆਂ ਤਬਦੀਲੀਆਂ ਜਾਂ ਕੋਈ ਵੀ ਨਹੀਂ ਰਿਕਾਰਡ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

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

ਮੈਂ - ਅਲੱਗ ਕਰਨਾ। ਸਮਾਨਾਂਤਰ ਚੱਲ ਰਹੇ ਲੈਣ-ਦੇਣ ਨੂੰ ਇੱਕ ਦੂਜੇ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਨਹੀਂ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।

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

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

IRIS ਵਿੱਚ ਲੈਣ-ਦੇਣ ਦਾ ਸਮਰਥਨ ਕਰਨ ਲਈ, ਹੇਠ ਲਿਖੀਆਂ ਕਮਾਂਡਾਂ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ: TSTART, TCOMMIT, ਟ੍ਰੋਲਬੈਕ.

1. ਪਰਮਾਣੂ

ਪਰਮਾਣੂ ਦੀ ਜਾਂਚ ਕਰਨ ਦਾ ਸਭ ਤੋਂ ਆਸਾਨ ਤਰੀਕਾ ਹੈ. ਅਸੀਂ ਡੇਟਾਬੇਸ ਕੰਸੋਲ ਤੋਂ ਜਾਂਚ ਕਰਦੇ ਹਾਂ।

Kill ^a
TSTART
Set ^a(1) = 1
Set ^a(2) = 2
Set ^a(3) = 3
TCOMMIT

ਫਿਰ ਅਸੀਂ ਸਿੱਟਾ ਕੱਢਦੇ ਹਾਂ:

Write ^a(1), “ ”, ^a(2), “ ”, ^a(3)

ਸਾਨੂੰ ਪ੍ਰਾਪਤ:

1 2 3

ਸਭ ਕੁਝ ਠੀਕ ਹੈ. ਐਟਮੀਸਿਟੀ ਬਣਾਈ ਰੱਖੀ ਜਾਂਦੀ ਹੈ: ਸਾਰੀਆਂ ਤਬਦੀਲੀਆਂ ਰਿਕਾਰਡ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ।

ਆਉ ਕੰਮ ਨੂੰ ਗੁੰਝਲਦਾਰ ਕਰੀਏ, ਇੱਕ ਤਰੁੱਟੀ ਪੇਸ਼ ਕਰੀਏ ਅਤੇ ਵੇਖੀਏ ਕਿ ਲੈਣ-ਦੇਣ ਨੂੰ ਕਿਵੇਂ ਸੁਰੱਖਿਅਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅੰਸ਼ਕ ਤੌਰ 'ਤੇ ਜਾਂ ਬਿਲਕੁਲ ਨਹੀਂ।

ਆਉ ਪਰਮਾਣੂ ਦੀ ਦੁਬਾਰਾ ਜਾਂਚ ਕਰੀਏ:

Kill ^A
TSTART
Set ^a(1) = 1
Set ^a(2) = 2
Set ^a(3) = 3

ਫਿਰ ਅਸੀਂ ਜ਼ਬਰਦਸਤੀ ਕੰਟੇਨਰ ਨੂੰ ਰੋਕਾਂਗੇ, ਇਸਨੂੰ ਲਾਂਚ ਕਰਾਂਗੇ ਅਤੇ ਵੇਖਾਂਗੇ.

docker kill my-iris

ਇਹ ਕਮਾਂਡ ਲਗਭਗ ਇੱਕ ਫੋਰਸ ਸ਼ੱਟਡਾਊਨ ਦੇ ਬਰਾਬਰ ਹੈ, ਕਿਉਂਕਿ ਇਹ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਤੁਰੰਤ ਰੋਕਣ ਲਈ ਇੱਕ ਸਿਗਕਿੱਲ ਸਿਗਨਲ ਭੇਜਦੀ ਹੈ।

ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਲੈਣ-ਦੇਣ ਨੂੰ ਅੰਸ਼ਕ ਤੌਰ 'ਤੇ ਬਚਾਇਆ ਗਿਆ ਸੀ?

WRITE ^a(1), ^a(2), ^a(3)
^
<UNDEFINED> ^a(1)

- ਨਹੀਂ, ਇਹ ਬਚਿਆ ਨਹੀਂ ਹੈ.

ਆਉ ਰੋਲਬੈਕ ਕਮਾਂਡ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ:

Kill ^A
TSTART
Set ^a(1) = 1
Set ^a(2) = 2
Set ^a(3) = 3
TROLLBACK

WRITE ^a(1), ^a(2), ^a(3)
^
<UNDEFINED> ^a(1)

ਕੁਝ ਵੀ ਨਹੀਂ ਬਚਿਆ।

2. ਇਕਸਾਰਤਾ

ਕਿਉਂਕਿ ਗਲੋਬਲ 'ਤੇ ਅਧਾਰਤ ਡੇਟਾਬੇਸ ਵਿੱਚ, ਕੁੰਜੀਆਂ ਗਲੋਬਲਾਂ 'ਤੇ ਵੀ ਬਣਾਈਆਂ ਜਾਂਦੀਆਂ ਹਨ (ਮੈਨੂੰ ਯਾਦ ਦਿਵਾਉਣ ਦਿਓ ਕਿ ਗਲੋਬਲ ਇੱਕ ਰਿਲੇਸ਼ਨਲ ਟੇਬਲ ਨਾਲੋਂ ਡੇਟਾ ਸਟੋਰ ਕਰਨ ਲਈ ਇੱਕ ਹੇਠਲੇ ਪੱਧਰ ਦਾ ਢਾਂਚਾ ਹੈ), ਇਕਸਾਰਤਾ ਦੀ ਜ਼ਰੂਰਤ ਨੂੰ ਪੂਰਾ ਕਰਨ ਲਈ, ਕੁੰਜੀ ਵਿੱਚ ਇੱਕ ਤਬਦੀਲੀ ਸ਼ਾਮਲ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ ਗਲੋਬਲ ਵਿੱਚ ਇੱਕ ਤਬਦੀਲੀ ਦੇ ਰੂਪ ਵਿੱਚ ਉਸੇ ਲੈਣ-ਦੇਣ ਵਿੱਚ.

ਉਦਾਹਰਨ ਲਈ, ਸਾਡੇ ਕੋਲ ਇੱਕ ਗਲੋਬਲ ^person ਹੈ, ਜਿਸ ਵਿੱਚ ਅਸੀਂ ਸ਼ਖਸੀਅਤਾਂ ਨੂੰ ਸਟੋਰ ਕਰਦੇ ਹਾਂ ਅਤੇ ਅਸੀਂ TIN ਨੂੰ ਇੱਕ ਕੁੰਜੀ ਵਜੋਂ ਵਰਤਦੇ ਹਾਂ।

^person(1234567, ‘firstname’) = ‘Sergey’
^person(1234567, ‘lastname’) = ‘Kamenev’
^person(1234567, ‘phone’) = ‘+74995555555
...

ਆਖਰੀ ਨਾਮ ਅਤੇ ਪਹਿਲੇ ਨਾਮ ਦੁਆਰਾ ਇੱਕ ਤੇਜ਼ ਖੋਜ ਕਰਨ ਲਈ, ਅਸੀਂ ^ਇੰਡੈਕਸ ਕੁੰਜੀ ਬਣਾਈ ਹੈ।

^index(‘Kamenev’, ‘Sergey’, 1234567) = 1

ਡੇਟਾਬੇਸ ਨੂੰ ਇਕਸਾਰ ਬਣਾਉਣ ਲਈ, ਸਾਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਵਿਅਕਤੀ ਨੂੰ ਜੋੜਨਾ ਚਾਹੀਦਾ ਹੈ:

TSTART
^person(1234567, ‘firstname’) = ‘Sergey’
^person(1234567, ‘lastname’) = ‘Kamenev’
^person(1234567, ‘phone’) = ‘+74995555555
^index(‘Kamenev’, ‘Sergey’, 1234567) = 1
TCOMMIT

ਇਸ ਅਨੁਸਾਰ, ਮਿਟਾਉਣ ਵੇਲੇ ਸਾਨੂੰ ਇੱਕ ਲੈਣ-ਦੇਣ ਦੀ ਵੀ ਵਰਤੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ:

TSTART
Kill ^person(1234567)
ZKill ^index(‘Kamenev’, ‘Sergey’, 1234567)
TCOMMIT

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

3. ਇਕੱਲਤਾ

ਇੱਥੋਂ ਹੀ ਜੰਗਲ ਸ਼ੁਰੂ ਹੁੰਦੇ ਹਨ। ਬਹੁਤ ਸਾਰੇ ਉਪਭੋਗਤਾ ਇੱਕੋ ਡੇਟਾਬੇਸ 'ਤੇ ਕੰਮ ਕਰਦੇ ਹਨ, ਉਸੇ ਡੇਟਾ ਨੂੰ ਬਦਲਦੇ ਹੋਏ.

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

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

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

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

ਸਮਾਨਾਂਤਰ ਵਿੱਚ ਟ੍ਰਾਂਜੈਕਸ਼ਨਾਂ ਨੂੰ ਚਲਾਉਣ ਵੇਲੇ, ਇਹ ਸਾਡੇ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਉਹ ਇੱਕ ਦੂਜੇ ਵਿੱਚ ਦਖਲ ਨਾ ਦੇਣ। ਇਹ ਇਕੱਲਤਾ ਦੀ ਵਿਸ਼ੇਸ਼ਤਾ ਹੈ.

SQL 4 ਅਲੱਗ-ਥਲੱਗ ਪੱਧਰਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ:

• ਬਿਨਾ ਪੜ੍ਹੋ
• ਕਮੇਟੀ ਪੜ੍ਹੋ
• ਦੁਹਰਾਉਣਯੋਗ ਪੜ੍ਹੋ
• ਗੰਭੀਰ

ਆਉ ਹਰ ਪੱਧਰ ਨੂੰ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਵੇਖੀਏ। ਹਰੇਕ ਪੱਧਰ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੀ ਲਾਗਤ ਲਗਭਗ ਤੇਜ਼ੀ ਨਾਲ ਵਧਦੀ ਹੈ।

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

ਕਮੇਟੀ ਪੜ੍ਹੋ ਇਕੱਲਤਾ ਦਾ ਅਗਲਾ ਪੱਧਰ ਹੈ, ਜੋ ਕਿ ਇਕ ਸਮਝੌਤਾ ਹੈ। ਲੈਣ-ਦੇਣ ਵਚਨਬੱਧਤਾ ਤੋਂ ਪਹਿਲਾਂ ਇੱਕ ਦੂਜੇ ਦੀਆਂ ਤਬਦੀਲੀਆਂ ਨੂੰ ਨਹੀਂ ਪੜ੍ਹ ਸਕਦੇ, ਪਰ ਉਹ ਵਚਨਬੱਧਤਾ ਤੋਂ ਬਾਅਦ ਕੀਤੇ ਗਏ ਕਿਸੇ ਵੀ ਬਦਲਾਅ ਨੂੰ ਪੜ੍ਹ ਸਕਦੇ ਹਨ।

ਜੇਕਰ ਸਾਡੇ ਕੋਲ ਇੱਕ ਲੰਮਾ ਲੈਣ-ਦੇਣ T1 ਹੈ, ਜਿਸ ਦੌਰਾਨ ਲੈਣ-ਦੇਣ T2, T3 ... Tn ਵਿੱਚ ਹੋਏ, ਜੋ T1 ਦੇ ਸਮਾਨ ਡੇਟਾ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ, ਤਾਂ T1 ਵਿੱਚ ਡੇਟਾ ਦੀ ਬੇਨਤੀ ਕਰਨ ਵੇਲੇ ਸਾਨੂੰ ਹਰ ਵਾਰ ਇੱਕ ਵੱਖਰਾ ਨਤੀਜਾ ਮਿਲੇਗਾ। ਇਸ ਵਰਤਾਰੇ ਨੂੰ ਨਾ-ਦੁਹਰਾਉਣਯੋਗ ਰੀਡਿੰਗ ਕਿਹਾ ਜਾਂਦਾ ਹੈ।

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

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

ਪਹਿਲਾਂ, ਆਓ ਇਹ ਪਤਾ ਕਰੀਏ ਕਿ ਕੀ ਮੁੱਖ ਥ੍ਰੈੱਡ ਤੋਂ ਇੱਕ ਲੈਣ-ਦੇਣ ਵਿੱਚ ਆਪਰੇਸ਼ਨਾਂ ਨੂੰ ਅਲੱਗ-ਥਲੱਗ ਕੀਤਾ ਗਿਆ ਹੈ। ਆਉ 2 ਟਰਮੀਨਲ ਵਿੰਡੋਜ਼ ਖੋਲ੍ਹੀਏ।

Kill ^t

Write ^t(1)
2

TSTART
Set ^t(1)=2

ਕੋਈ ਅਲੱਗ-ਥਲੱਗ ਨਹੀਂ ਹੈ। ਇੱਕ ਥਰਿੱਡ ਦੇਖਦਾ ਹੈ ਕਿ ਦੂਜਾ ਜਿਸਨੇ ਲੈਣ-ਦੇਣ ਨੂੰ ਖੋਲ੍ਹਿਆ ਹੈ ਉਹ ਕੀ ਕਰ ਰਿਹਾ ਹੈ।

ਆਓ ਦੇਖੀਏ ਕਿ ਵੱਖ-ਵੱਖ ਥਰਿੱਡਾਂ ਦੇ ਲੈਣ-ਦੇਣ ਇਹ ਦੇਖਦੇ ਹਨ ਕਿ ਉਨ੍ਹਾਂ ਦੇ ਅੰਦਰ ਕੀ ਹੋ ਰਿਹਾ ਹੈ.

ਚਲੋ 2 ਟਰਮੀਨਲ ਵਿੰਡੋਜ਼ ਖੋਲ੍ਹੀਏ ਅਤੇ 2 ਟ੍ਰਾਂਜੈਕਸ਼ਨਾਂ ਨੂੰ ਸਮਾਨਾਂਤਰ ਵਿੱਚ ਖੋਲ੍ਹੀਏ।

kill ^t
TSTART
Write ^t(1)
3

TSTART
Set ^t(1)=3

ਸਮਾਨਾਂਤਰ ਲੈਣ-ਦੇਣ ਇੱਕ ਦੂਜੇ ਦੇ ਡੇਟਾ ਨੂੰ ਦੇਖਦੇ ਹਨ। ਇਸ ਲਈ, ਸਾਨੂੰ ਸਭ ਤੋਂ ਸਰਲ, ਪਰ ਸਭ ਤੋਂ ਤੇਜ਼ ਅਲੱਗ-ਥਲੱਗ ਪੱਧਰ ਵੀ ਮਿਲਿਆ, ਅਣਕੰਮਿਤ ਪੜ੍ਹੋ।

ਸਿਧਾਂਤਕ ਤੌਰ 'ਤੇ, ਗਲੋਬਲਾਂ ਲਈ ਇਹ ਉਮੀਦ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ, ਜਿਸ ਲਈ ਪ੍ਰਦਰਸ਼ਨ ਹਮੇਸ਼ਾ ਤਰਜੀਹ ਰਿਹਾ ਹੈ।

ਉਦੋਂ ਕੀ ਜੇ ਸਾਨੂੰ ਗਲੋਬਲਾਂ 'ਤੇ ਓਪਰੇਸ਼ਨਾਂ ਵਿਚ ਉੱਚ ਪੱਧਰੀ ਇਕੱਲਤਾ ਦੀ ਲੋੜ ਹੈ?

ਇੱਥੇ ਤੁਹਾਨੂੰ ਇਸ ਬਾਰੇ ਸੋਚਣ ਦੀ ਲੋੜ ਹੈ ਕਿ ਅਲੱਗ-ਥਲੱਗ ਪੱਧਰਾਂ ਦੀ ਲੋੜ ਕਿਉਂ ਹੈ ਅਤੇ ਉਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ।

ਸਭ ਤੋਂ ਉੱਚੇ ਅਲੱਗ-ਥਲੱਗ ਪੱਧਰ, SERIALIZE, ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਸਮਾਨਾਂਤਰ ਵਿੱਚ ਕੀਤੇ ਗਏ ਲੈਣ-ਦੇਣ ਦਾ ਨਤੀਜਾ ਉਹਨਾਂ ਦੇ ਕ੍ਰਮਵਾਰ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦੇ ਬਰਾਬਰ ਹੁੰਦਾ ਹੈ, ਜੋ ਕਿ ਟੱਕਰਾਂ ਦੀ ਅਣਹੋਂਦ ਦੀ ਗਰੰਟੀ ਦਿੰਦਾ ਹੈ।

ਅਸੀਂ ਆਬਜੈਕਟ ਸਕ੍ਰਿਪਟ ਵਿੱਚ ਸਮਾਰਟ ਲਾਕ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਜਿਹਾ ਕਰ ਸਕਦੇ ਹਾਂ, ਜਿਸ ਦੇ ਬਹੁਤ ਸਾਰੇ ਵੱਖ-ਵੱਖ ਉਪਯੋਗ ਹਨ: ਤੁਸੀਂ ਕਮਾਂਡ ਨਾਲ ਨਿਯਮਤ, ਵਾਧਾ, ਮਲਟੀਪਲ ਲਾਕਿੰਗ ਕਰ ਸਕਦੇ ਹੋ LOCK.

ਹੇਠਲੇ ਅਲੱਗ-ਥਲੱਗ ਪੱਧਰ ਡੇਟਾਬੇਸ ਦੀ ਗਤੀ ਨੂੰ ਵਧਾਉਣ ਲਈ ਤਿਆਰ ਕੀਤੇ ਗਏ ਵਪਾਰ-ਆਫ ਹਨ।

ਆਓ ਦੇਖੀਏ ਕਿ ਅਸੀਂ ਤਾਲੇ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਵੱਖ-ਵੱਖ ਪੱਧਰਾਂ ਨੂੰ ਕਿਵੇਂ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹਾਂ।

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

ਰੂਸੀ ਅਤੇ ਅੰਗਰੇਜ਼ੀ ਵਿੱਚ ਦੋ-ਪੜਾਅ ਬਲਾਕਿੰਗ ਵਿਧੀ ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ:

→ ਦੋ-ਪੜਾਅ ਬਲਾਕਿੰਗ
→ ਦੋ-ਪੜਾਅ ਲੌਕਿੰਗ

ਮੁਸ਼ਕਲ ਇਹ ਹੈ ਕਿ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਦੇ ਦੌਰਾਨ ਡੇਟਾਬੇਸ ਦੀ ਸਥਿਤੀ ਅਸੰਗਤ ਹੋ ਸਕਦੀ ਹੈ, ਪਰ ਇਹ ਅਸੰਗਤ ਡੇਟਾ ਹੋਰ ਪ੍ਰਕਿਰਿਆਵਾਂ ਲਈ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ. ਇਸ ਤੋਂ ਕਿਵੇਂ ਬਚਣਾ ਹੈ?

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

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

ਡੇਟਾ ਤਬਦੀਲੀਆਂ ਲਈ ਵਿਸ਼ੇਸ਼ ਲਾਕ ਵਰਤੇ ਜਾਂਦੇ ਹਨ - ਕੇਵਲ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਅਜਿਹੇ ਲਾਕ ਨੂੰ ਲੈ ਸਕਦੀ ਹੈ। ਇੱਕ ਨਿਵੇਕਲਾ ਤਾਲਾ ਇਹਨਾਂ ਦੁਆਰਾ ਲਿਆ ਜਾ ਸਕਦਾ ਹੈ:

1. ਕੋਈ ਵੀ ਪ੍ਰਕਿਰਿਆ ਜੇਕਰ ਡੇਟਾ ਮੁਫਤ ਹੈ
2. ਸਿਰਫ਼ ਉਹ ਪ੍ਰਕਿਰਿਆ ਜਿਸ ਵਿੱਚ ਇਸ ਡੇਟਾ 'ਤੇ ਇੱਕ ਸਾਂਝਾ ਲਾਕ ਹੈ ਅਤੇ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਲਾਕ ਦੀ ਬੇਨਤੀ ਕਰਨ ਵਾਲਾ ਪਹਿਲਾ ਵਿਅਕਤੀ ਸੀ।

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

READ_COMMITTED - ਇਸ ਪੱਧਰ ਦਾ ਸਾਰ ਇਹ ਹੈ ਕਿ ਅਸੀਂ ਹੋਰ ਥ੍ਰੈਡਾਂ ਤੋਂ ਸਿਰਫ ਪ੍ਰਤੀਬੱਧ ਡੇਟਾ ਦੇਖਦੇ ਹਾਂ। ਜੇਕਰ ਕਿਸੇ ਹੋਰ ਟ੍ਰਾਂਜੈਕਸ਼ਨ ਵਿੱਚ ਡੇਟਾ ਅਜੇ ਤੱਕ ਪ੍ਰਤੀਬੱਧ ਨਹੀਂ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਅਸੀਂ ਇਸਦਾ ਪੁਰਾਣਾ ਸੰਸਕਰਣ ਦੇਖਦੇ ਹਾਂ।

ਇਹ ਸਾਨੂੰ ਲਾਕ ਦੇ ਜਾਰੀ ਹੋਣ ਦੀ ਉਡੀਕ ਕਰਨ ਦੀ ਬਜਾਏ ਕੰਮ ਨੂੰ ਸਮਾਨਾਂਤਰ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ.

ਵਿਸ਼ੇਸ਼ ਚਾਲਾਂ ਤੋਂ ਬਿਨਾਂ, ਅਸੀਂ IRIS ਵਿੱਚ ਡੇਟਾ ਦੇ ਪੁਰਾਣੇ ਸੰਸਕਰਣ ਨੂੰ ਨਹੀਂ ਦੇਖ ਸਕਾਂਗੇ, ਇਸ ਲਈ ਸਾਨੂੰ ਤਾਲੇ ਨਾਲ ਕੰਮ ਕਰਨਾ ਪਵੇਗਾ।

ਇਸ ਅਨੁਸਾਰ, ਸਾਨੂੰ ਡੇਟਾ ਨੂੰ ਸਿਰਫ ਇਕਸਾਰਤਾ ਦੇ ਪਲਾਂ 'ਤੇ ਪੜ੍ਹਨ ਦੀ ਆਗਿਆ ਦੇਣ ਲਈ ਸਾਂਝੇ ਤਾਲੇ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਪਵੇਗੀ।

ਮੰਨ ਲਓ ਕਿ ਸਾਡੇ ਕੋਲ ਇੱਕ ਉਪਭੋਗਤਾ ਅਧਾਰ ^ਵਿਅਕਤੀ ਹੈ ਜੋ ਇੱਕ ਦੂਜੇ ਨੂੰ ਪੈਸੇ ਟ੍ਰਾਂਸਫਰ ਕਰਦੇ ਹਨ।

ਵਿਅਕਤੀ 123 ਤੋਂ ਵਿਅਕਤੀ 242 ਵਿੱਚ ਤਬਾਦਲੇ ਦਾ ਪਲ:

LOCK +^person(123), +^person(242)
Set ^person(123, amount) = ^person(123, amount) - amount
Set ^person(242, amount) = ^person(242, amount) + amount
LOCK -^person(123), -^person(242)

ਡੈਬਿਟ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਵਿਅਕਤੀ 123 ਤੋਂ ਪੈਸੇ ਦੀ ਰਕਮ ਦੀ ਬੇਨਤੀ ਕਰਨ ਦਾ ਪਲ ਇੱਕ ਨਿਵੇਕਲੇ ਬਲਾਕ (ਮੂਲ ਰੂਪ ਵਿੱਚ) ਦੇ ਨਾਲ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ:

LOCK +^person(123)
Write ^person(123)

ਅਤੇ ਜੇਕਰ ਤੁਹਾਨੂੰ ਆਪਣੇ ਨਿੱਜੀ ਖਾਤੇ ਵਿੱਚ ਖਾਤੇ ਦੀ ਸਥਿਤੀ ਦਿਖਾਉਣ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਇੱਕ ਸਾਂਝੇ ਲਾਕ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ ਜਾਂ ਇਸਨੂੰ ਬਿਲਕੁਲ ਨਹੀਂ ਵਰਤ ਸਕਦੇ ਹੋ:

LOCK +^person(123)#”S”
Write ^person(123)

ਹਾਲਾਂਕਿ, ਜੇਕਰ ਅਸੀਂ ਇਹ ਮੰਨ ਲੈਂਦੇ ਹਾਂ ਕਿ ਡੇਟਾਬੇਸ ਓਪਰੇਸ਼ਨ ਲਗਭਗ ਤੁਰੰਤ ਕੀਤੇ ਜਾਂਦੇ ਹਨ (ਮੈਨੂੰ ਯਾਦ ਦਿਵਾਉਣ ਦਿਓ ਕਿ ਗਲੋਬਲ ਇੱਕ ਰਿਲੇਸ਼ਨਲ ਟੇਬਲ ਨਾਲੋਂ ਬਹੁਤ ਘੱਟ-ਪੱਧਰ ਦਾ ਢਾਂਚਾ ਹੈ), ਤਾਂ ਇਸ ਪੱਧਰ ਦੀ ਜ਼ਰੂਰਤ ਘੱਟ ਜਾਂਦੀ ਹੈ।

ਦੁਹਰਾਉਣਯੋਗ ਪੜ੍ਹੋ - ਇਹ ਅਲੱਗ-ਥਲੱਗ ਪੱਧਰ ਡੇਟਾ ਦੇ ਕਈ ਰੀਡਜ਼ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ ਜਿਸ ਨੂੰ ਸਮਕਾਲੀ ਲੈਣ-ਦੇਣ ਦੁਆਰਾ ਸੋਧਿਆ ਜਾ ਸਕਦਾ ਹੈ।

ਇਸ ਅਨੁਸਾਰ, ਸਾਨੂੰ ਸਾਡੇ ਦੁਆਰਾ ਬਦਲੇ ਗਏ ਡੇਟਾ ਨੂੰ ਪੜ੍ਹਨ ਲਈ ਇੱਕ ਸਾਂਝਾ ਲਾਕ ਲਗਾਉਣਾ ਹੋਵੇਗਾ ਅਤੇ ਜੋ ਡੇਟਾ ਅਸੀਂ ਬਦਲਦੇ ਹਾਂ ਉਸ 'ਤੇ ਵਿਸ਼ੇਸ਼ ਲਾਕ ਲਗਾਉਣਾ ਹੋਵੇਗਾ।

ਖੁਸ਼ਕਿਸਮਤੀ ਨਾਲ, LOCK ਆਪਰੇਟਰ ਤੁਹਾਨੂੰ ਸਾਰੇ ਲੋੜੀਂਦੇ ਲਾਕਾਂ ਨੂੰ ਵਿਸਥਾਰ ਵਿੱਚ ਸੂਚੀਬੱਧ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਜਿਨ੍ਹਾਂ ਵਿੱਚੋਂ ਇੱਕ ਬਿਆਨ ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਹੋ ਸਕਦੇ ਹਨ।

LOCK +^person(123, amount)#”S”
чтение ^person(123, amount)

ਹੋਰ ਓਪਰੇਸ਼ਨ (ਇਸ ਸਮੇਂ ਪੈਰਲਲ ਥ੍ਰੈਡਸ ^person(123, ਰਕਮ) ਨੂੰ ਬਦਲਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹਨ, ਪਰ ਨਹੀਂ ਕਰ ਸਕਦੇ)

LOCK +^person(123, amount)
изменение ^person(123, amount)
LOCK -^person(123, amount)

чтение ^person(123, amount)
LOCK -^person(123, amount)#”S”

ਕਾਮਿਆਂ ਦੁਆਰਾ ਵੱਖ ਕੀਤੇ ਤਾਲੇ ਸੂਚੀਬੱਧ ਕਰਦੇ ਸਮੇਂ, ਉਹਨਾਂ ਨੂੰ ਕ੍ਰਮਵਾਰ ਲਿਆ ਜਾਂਦਾ ਹੈ, ਪਰ ਜੇਕਰ ਤੁਸੀਂ ਅਜਿਹਾ ਕਰਦੇ ਹੋ:

LOCK +(^person(123),^person(242))

ਫਿਰ ਉਹ ਸਾਰੇ ਇੱਕ ਵਾਰ 'ਤੇ ਪਰਮਾਣੂ ਲਿਆ ਰਹੇ ਹਨ.

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

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

4. ਟਿਕਾਊਤਾ

ਮੈਂ ਵਰਤਦੇ ਹੋਏ ਕੰਟੇਨਰ ਦੀ ਸਖ਼ਤ ਕਟਿੰਗ ਦੇ ਨਾਲ ਟੈਸਟ ਕੀਤੇ

docker kill my-iris

ਆਧਾਰ ਨੇ ਉਨ੍ਹਾਂ ਨੂੰ ਚੰਗੀ ਤਰ੍ਹਾਂ ਬਰਦਾਸ਼ਤ ਕੀਤਾ। ਕੋਈ ਸਮੱਸਿਆ ਨਹੀਂ ਪਛਾਣੀ ਗਈ।

ਸਿੱਟਾ

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

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

ਗਲੋਬਲਾਂ 'ਤੇ ਲੈਣ-ਦੇਣ ਦੀ ਸ਼ੁੱਧਤਾ ਅਤੇ ਗਤੀ ਬਹੁਤ ਜ਼ਿਆਦਾ ਪ੍ਰੋਗਰਾਮਰ ਦੇ ਹੁਨਰ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ: ਪੜ੍ਹਨ ਵੇਲੇ ਵਧੇਰੇ ਵਿਆਪਕ ਤੌਰ 'ਤੇ ਸਾਂਝੇ ਕੀਤੇ ਤਾਲੇ ਵਰਤੇ ਜਾਂਦੇ ਹਨ, ਇਕੱਲਤਾ ਦਾ ਪੱਧਰ ਉੱਚਾ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਜਿੰਨਾ ਜ਼ਿਆਦਾ ਸੰਕੁਚਿਤ ਨਿਵੇਕਲੇ ਤਾਲੇ ਲਏ ਜਾਂਦੇ ਹਨ, ਕਾਰਗੁਜ਼ਾਰੀ ਓਨੀ ਹੀ ਤੇਜ਼ ਹੁੰਦੀ ਹੈ।

ਸਰੋਤ: www.habr.com