2019 ਦੇ ਪਤਝੜ ਵਿੱਚ, Mail.ru ਕਲਾਉਡ ਆਈਓਐਸ ਟੀਮ ਵਿੱਚ ਇੱਕ ਲੰਬੇ ਸਮੇਂ ਤੋਂ ਉਡੀਕਿਆ ਗਿਆ ਇਵੈਂਟ ਹੋਇਆ। ਐਪਲੀਕੇਸ਼ਨ ਸਟੇਟ ਦੇ ਨਿਰੰਤਰ ਸਟੋਰੇਜ ਲਈ ਮੁੱਖ ਡੇਟਾਬੇਸ ਮੋਬਾਈਲ ਸੰਸਾਰ ਲਈ ਕਾਫ਼ੀ ਵਿਦੇਸ਼ੀ ਬਣ ਗਿਆ ਹੈ ਲਾਈਟਨਿੰਗ ਮੈਮੋਰੀ-ਮੈਪਡ ਡੇਟਾਬੇਸ (LMDB)। ਕੱਟ ਦੇ ਤਹਿਤ, ਤੁਹਾਡੇ ਧਿਆਨ ਨੂੰ ਚਾਰ ਭਾਗਾਂ ਵਿੱਚ ਇਸਦੀ ਵਿਸਤ੍ਰਿਤ ਸਮੀਖਿਆ ਵੱਲ ਸੱਦਾ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। ਪਹਿਲਾਂ, ਆਓ ਅਜਿਹੀ ਗੈਰ-ਮਾਮੂਲੀ ਅਤੇ ਮੁਸ਼ਕਲ ਚੋਣ ਦੇ ਕਾਰਨਾਂ ਬਾਰੇ ਗੱਲ ਕਰੀਏ. ਫਿਰ ਆਓ LMDB ਆਰਕੀਟੈਕਚਰ ਦੇ ਕੇਂਦਰ ਵਿੱਚ ਤਿੰਨ ਵ੍ਹੇਲਾਂ ਦੇ ਵਿਚਾਰ ਵੱਲ ਵਧੀਏ: ਮੈਮੋਰੀ-ਮੈਪਡ ਫਾਈਲਾਂ, ਬੀ + ਟ੍ਰੀ, ਟ੍ਰਾਂਜੈਕਸ਼ਨਲ ਅਤੇ ਮਲਟੀਵਰਜ਼ਨਿੰਗ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਕਾਪੀ-ਆਨ-ਰਾਈਟ ਪਹੁੰਚ। ਅੰਤ ਵਿੱਚ, ਮਿਠਆਈ ਲਈ - ਅਮਲੀ ਹਿੱਸਾ. ਇਸ ਵਿੱਚ, ਅਸੀਂ ਦੇਖਾਂਗੇ ਕਿ ਹੇਠਲੇ-ਪੱਧਰ ਦੇ ਮੁੱਖ-ਮੁੱਲ API ਦੇ ਸਿਖਰ 'ਤੇ, ਇੱਕ ਸੂਚਕਾਂਕ ਸਮੇਤ, ਕਈ ਟੇਬਲਾਂ ਦੇ ਨਾਲ ਇੱਕ ਬੇਸ ਸਕੀਮਾ ਨੂੰ ਕਿਵੇਂ ਡਿਜ਼ਾਈਨ ਕਰਨਾ ਅਤੇ ਲਾਗੂ ਕਰਨਾ ਹੈ।

ਸਮੱਗਰੀ

ਲਾਗੂ ਕਰਨ ਦੀ ਪ੍ਰੇਰਣਾ
LMDB ਦੀ ਸਥਿਤੀ
ਤਿੰਨ ਵ੍ਹੇਲ LMDB
3.1. ਵ੍ਹੇਲ #1. ਮੈਮੋਰੀ-ਮੈਪ ਕੀਤੀਆਂ ਫਾਈਲਾਂ
3.2. ਵ੍ਹੇਲ #2. ਬੀ+-ਰੁੱਖ
3.3. ਵ੍ਹੇਲ #3. ਕਾਪੀ-ਆਨ-ਲਿਖਣ
ਕੁੰਜੀ-ਮੁੱਲ API ਦੇ ਸਿਖਰ 'ਤੇ ਇੱਕ ਡਾਟਾ ਸਕੀਮਾ ਡਿਜ਼ਾਈਨ ਕਰਨਾ
4.1. ਬੁਨਿਆਦੀ ਐਬਸਟਰੈਕਸ਼ਨ
4.2. ਟੇਬਲ ਮਾਡਲਿੰਗ
4.3. ਟੇਬਲ ਵਿਚਕਾਰ ਮਾਡਲਿੰਗ ਸਬੰਧ

1. ਲਾਗੂ ਕਰਨ ਦੀ ਪ੍ਰੇਰਣਾ

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

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

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

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

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

ਡਾਟਾਬੇਸ ਦੀ ਚੋਣ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਨ ਵਾਲਾ ਦੂਜਾ ਮਹੱਤਵਪੂਰਨ ਕਾਰਕ ਸਾਡਾ ਕਲਾਉਡ API ਸੀ। ਇਹ ਸਿੰਕ੍ਰੋਨਾਈਜ਼ੇਸ਼ਨ ਲਈ ਗਿੱਟ ਪਹੁੰਚ ਤੋਂ ਪ੍ਰੇਰਿਤ ਸੀ। ਉਸ ਵਾਂਗ ਅਸੀਂ ਉਦੇਸ਼ ਰੱਖਦੇ ਹਾਂ ਔਫਲਾਈਨ ਪਹਿਲਾ API, ਜੋ ਕਿ ਕਲਾਉਡ ਕਲਾਇੰਟਸ ਲਈ ਢੁਕਵੇਂ ਤੋਂ ਵੱਧ ਦਿਖਦਾ ਹੈ। ਇਹ ਮੰਨਿਆ ਗਿਆ ਸੀ ਕਿ ਉਹ ਸਿਰਫ ਇੱਕ ਵਾਰ ਕਲਾਉਡ ਦੀ ਪੂਰੀ ਸਥਿਤੀ ਨੂੰ ਪੰਪ ਕਰਨਗੇ, ਅਤੇ ਫਿਰ ਬਹੁਤ ਸਾਰੇ ਮਾਮਲਿਆਂ ਵਿੱਚ ਰੋਲਿੰਗ ਤਬਦੀਲੀਆਂ ਦੁਆਰਾ ਸਮਕਾਲੀਕਰਨ ਹੋਵੇਗਾ। ਹਾਏ, ਇਹ ਸੰਭਾਵਨਾ ਅਜੇ ਵੀ ਸਿਰਫ ਸਿਧਾਂਤਕ ਜ਼ੋਨ ਵਿੱਚ ਹੈ, ਅਤੇ ਅਭਿਆਸ ਵਿੱਚ, ਗਾਹਕਾਂ ਨੇ ਪੈਚਾਂ ਨਾਲ ਕੰਮ ਕਰਨਾ ਨਹੀਂ ਸਿੱਖਿਆ ਹੈ. ਇਸ ਦੇ ਕਈ ਬਾਹਰਮੁਖੀ ਕਾਰਨ ਹਨ, ਜਿਨ੍ਹਾਂ ਨੂੰ ਜਾਣ-ਪਛਾਣ ਵਿਚ ਦੇਰੀ ਨਾ ਕਰਨ ਲਈ, ਅਸੀਂ ਬਰੈਕਟਾਂ ਤੋਂ ਬਾਹਰ ਚਲੇ ਜਾਵਾਂਗੇ। ਹੁਣ ਹੋਰ ਵੀ ਦਿਲਚਸਪ ਸਬਕ ਦੇ ਸਿੱਖਿਆਦਾਇਕ ਨਤੀਜੇ ਹਨ ਕਿ ਕੀ ਹੁੰਦਾ ਹੈ ਜਦੋਂ API ਨੇ "A" ਕਿਹਾ ਅਤੇ ਇਸਦੇ ਖਪਤਕਾਰ ਨੇ "B" ਨਹੀਂ ਕਿਹਾ।

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

ਹੋਰ ਲੋੜਾਂ ਵਧੇਰੇ ਰਵਾਇਤੀ ਹਨ, ਅਤੇ ਉਹਨਾਂ ਦੀ ਪੂਰੀ ਸੂਚੀ ਹੇਠਾਂ ਦਿੱਤੀ ਗਈ ਹੈ।

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

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

2. LMDB ਪੋਜੀਸ਼ਨਿੰਗ

LMDB ਇੱਕ ਲਾਇਬ੍ਰੇਰੀ ਹੈ, ਬਹੁਤ ਛੋਟੀ (ਸਿਰਫ 10K ਲਾਈਨਾਂ), ਜੋ ਡੇਟਾਬੇਸ ਦੀ ਸਭ ਤੋਂ ਨੀਵੀਂ ਬੁਨਿਆਦੀ ਪਰਤ ਨੂੰ ਲਾਗੂ ਕਰਦੀ ਹੈ - ਸਟੋਰੇਜ।

ਉਪਰੋਕਤ ਚਿੱਤਰ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ SQLite ਨਾਲ LMDB ਦੀ ਤੁਲਨਾ ਕਰਨਾ, ਜੋ ਕਿ ਉੱਚ ਪੱਧਰਾਂ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ, ਆਮ ਤੌਰ 'ਤੇ ਕੋਰ ਡੇਟਾ ਵਾਲੇ SQLite ਨਾਲੋਂ ਜ਼ਿਆਦਾ ਸਹੀ ਨਹੀਂ ਹੈ। ਸਮਾਨ ਪ੍ਰਤੀਯੋਗੀ - ਬਰਕਲੇਡੀਬੀ, ਲੇਵਲਡੀਬੀ, ਸੋਫੀਆ, ਰੌਕਸਡੀਬੀ, ਆਦਿ ਦੇ ਤੌਰ 'ਤੇ ਸਮਾਨ ਸਟੋਰੇਜ ਇੰਜਣਾਂ ਦਾ ਹਵਾਲਾ ਦੇਣਾ ਵਧੇਰੇ ਉਚਿਤ ਹੋਵੇਗਾ। ਇੱਥੇ ਵੀ ਵਿਕਾਸ ਹਨ ਜਿੱਥੇ LMDB SQLite ਲਈ ਸਟੋਰੇਜ ਇੰਜਣ ਦੇ ਹਿੱਸੇ ਵਜੋਂ ਕੰਮ ਕਰਦਾ ਹੈ। ਅਜਿਹਾ ਪਹਿਲਾ ਪ੍ਰਯੋਗ 2012 ਵਿੱਚ ਕੀਤਾ ਗਿਆ ਸੀ ਖਰਚ ਕੀਤਾ ਲੇਖਕ LMDB ਹਾਵਰਡ ਚੂ. Результаты ਇਹ ਇੰਨਾ ਦਿਲਚਸਪ ਸਾਬਤ ਹੋਇਆ ਕਿ ਉਸਦੀ ਪਹਿਲਕਦਮੀ ਨੂੰ ਓ.ਐਸ.ਐਸ. ਦੇ ਉਤਸ਼ਾਹੀ ਲੋਕਾਂ ਦੁਆਰਾ ਚੁੱਕਿਆ ਗਿਆ, ਅਤੇ ਇਸਦੇ ਚਿਹਰੇ ਵਿੱਚ ਇਸਦੀ ਨਿਰੰਤਰਤਾ ਪਾਈ ਗਈ। LumoSQL. ਜਨਵਰੀ 2020 ਵਿੱਚ ਇਸ ਪ੍ਰੋਜੈਕਟ ਦਾ ਲੇਖਕ ਡੇਨ ਸ਼ੀਅਰਰ ਹੈ ਪੇਸ਼ ਕੀਤਾ ਇਹ LinuxConfAu 'ਤੇ ਹੈ।

LMDB ਦੀ ਮੁੱਖ ਵਰਤੋਂ ਐਪਲੀਕੇਸ਼ਨ ਡੇਟਾਬੇਸ ਲਈ ਇੱਕ ਇੰਜਣ ਵਜੋਂ ਹੈ। ਲਾਇਬ੍ਰੇਰੀ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਆਪਣੀ ਦਿੱਖ ਦੇਣ ਵਾਲੀ ਹੈ OpenLDAP, ਜੋ ਆਪਣੇ ਪ੍ਰੋਜੈਕਟ ਦੇ ਅਧਾਰ ਵਜੋਂ ਬਰਕਲੇਡੀਬੀ ਤੋਂ ਬਹੁਤ ਅਸੰਤੁਸ਼ਟ ਸਨ। ਨਿਮਰ ਲਾਇਬ੍ਰੇਰੀ ਤੋਂ ਦੂਰ ਧੱਕਾ btree, ਹਾਵਰਡ ਚੂ ਸਾਡੇ ਸਮੇਂ ਦੇ ਸਭ ਤੋਂ ਪ੍ਰਸਿੱਧ ਵਿਕਲਪਾਂ ਵਿੱਚੋਂ ਇੱਕ ਬਣਾਉਣ ਦੇ ਯੋਗ ਸੀ. ਉਸਨੇ ਆਪਣੀ ਬਹੁਤ ਵਧੀਆ ਰਿਪੋਰਟ ਇਸ ਕਹਾਣੀ ਦੇ ਨਾਲ-ਨਾਲ LMDB ਦੇ ਅੰਦਰੂਨੀ ਢਾਂਚੇ ਨੂੰ ਸਮਰਪਿਤ ਕੀਤੀ। "ਦਿ ਲਾਈਟਨਿੰਗ ਮੈਮੋਰੀ-ਮੈਪਡ ਡੇਟਾਬੇਸ". ਲਿਓਨਿਡ ਯੂਰੀਏਵ (ਉਰਫ਼ yleo) ਹਾਈਲੋਡ 2015 'ਤੇ ਆਪਣੇ ਭਾਸ਼ਣ ਵਿੱਚ ਸਕਾਰਾਤਮਕ ਤਕਨਾਲੋਜੀ ਤੋਂ "LMDB ਇੰਜਣ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਚੈਂਪੀਅਨ ਹੈ". ਇਸ ਵਿੱਚ, ਉਹ ReOpenLDAP ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੇ ਸਮਾਨ ਕਾਰਜ ਦੇ ਸੰਦਰਭ ਵਿੱਚ LMDB ਬਾਰੇ ਗੱਲ ਕਰਦਾ ਹੈ, ਅਤੇ LevelDB ਪਹਿਲਾਂ ਹੀ ਤੁਲਨਾਤਮਕ ਆਲੋਚਨਾ ਵਿੱਚੋਂ ਲੰਘ ਚੁੱਕਾ ਹੈ। ਲਾਗੂ ਕਰਨ ਦੇ ਨਤੀਜੇ ਵਜੋਂ, ਸਕਾਰਾਤਮਕ ਤਕਨਾਲੋਜੀਆਂ ਨੇ ਇੱਕ ਸਰਗਰਮੀ ਨਾਲ ਵਿਕਾਸਸ਼ੀਲ ਫੋਰਕ ਵੀ ਪ੍ਰਾਪਤ ਕੀਤਾ MDBX ਬਹੁਤ ਹੀ ਸੁਆਦੀ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ, ਅਨੁਕੂਲਤਾਵਾਂ ਅਤੇ ਨਾਲ ਬੱਗ ਫਿਕਸ.

LMDB ਨੂੰ ਅਕਸਰ ਸਟੋਰੇਜ ਦੇ ਨਾਲ-ਨਾਲ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਮੋਜ਼ੀਲਾ ਫਾਇਰਫਾਕਸ ਬਰਾਊਜ਼ਰ ਚੁਣਿਆ ਇਹ ਕਈ ਲੋੜਾਂ ਲਈ, ਅਤੇ, ਸੰਸਕਰਣ 9, Xcode ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ ਤਰਜੀਹੀ ਸੂਚਕਾਂਕ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਇਸਦਾ SQLite.

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

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

3. ਤਿੰਨ ਵ੍ਹੇਲ LMDB

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

ਡਿਸਕ ਨਾਲ ਕੰਮ ਕਰਨ ਅਤੇ ਅੰਦਰੂਨੀ ਡਾਟਾ ਢਾਂਚੇ ਨੂੰ ਸਮਕਾਲੀ ਕਰਨ ਲਈ ਇੱਕ ਵਿਧੀ ਵਜੋਂ ਮੈਮੋਰੀ-ਮੈਪ ਕੀਤੀਆਂ ਫਾਈਲਾਂ।
ਬੀ+-ਟ੍ਰੀ ਸਟੋਰ ਕੀਤੇ ਡੇਟਾ ਢਾਂਚੇ ਦੇ ਸੰਗਠਨ ਵਜੋਂ।
ACID ਟ੍ਰਾਂਜੈਕਸ਼ਨਲ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਅਤੇ ਮਲਟੀਵਰਜ਼ਨਿੰਗ ਪ੍ਰਦਾਨ ਕਰਨ ਲਈ ਇੱਕ ਪਹੁੰਚ ਵਜੋਂ ਕਾਪੀ-ਆਨ-ਰਾਈਟ।

3.1 ਵ੍ਹੇਲ #1. ਮੈਮੋਰੀ-ਮੈਪ ਕੀਤੀਆਂ ਫਾਈਲਾਂ

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

ਕਈ ਪ੍ਰਕਿਰਿਆਵਾਂ ਤੋਂ ਕੰਮ ਕਰਦੇ ਸਮੇਂ ਸਟੋਰੇਜ ਵਿੱਚ ਡੇਟਾ ਦੀ ਇਕਸਾਰਤਾ ਨੂੰ ਬਣਾਈ ਰੱਖਣਾ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦੀ ਜ਼ਿੰਮੇਵਾਰੀ ਬਣ ਜਾਂਦੀ ਹੈ। ਅਗਲੇ ਭਾਗ ਵਿੱਚ, ਇਸ ਮਕੈਨਿਕ ਬਾਰੇ ਵਿਸਥਾਰ ਵਿੱਚ ਅਤੇ ਤਸਵੀਰਾਂ ਨਾਲ ਚਰਚਾ ਕੀਤੀ ਗਈ ਹੈ।
ਕੈਚਾਂ ਦੀ ਅਣਹੋਂਦ ਗਤੀਸ਼ੀਲ ਵੰਡ ਨਾਲ ਜੁੜੇ ਓਵਰਹੈੱਡ ਦੇ LMDB ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਰਾਹਤ ਦਿੰਦੀ ਹੈ। ਅਭਿਆਸ ਵਿੱਚ ਡੇਟਾ ਨੂੰ ਪੜ੍ਹਨਾ ਪੁਆਇੰਟਰ ਨੂੰ ਵਰਚੁਅਲ ਮੈਮੋਰੀ ਵਿੱਚ ਸਹੀ ਪਤੇ ਤੇ ਸੈੱਟ ਕਰ ਰਿਹਾ ਹੈ ਅਤੇ ਹੋਰ ਕੁਝ ਨਹੀਂ। ਕਲਪਨਾ ਵਰਗੀ ਆਵਾਜ਼, ਪਰ ਰਿਪੋਜ਼ਟਰੀ ਸਰੋਤ ਵਿੱਚ, ਸਾਰੀਆਂ ਕਾਲੋਕ ਕਾਲਾਂ ਰਿਪੋਜ਼ਟਰੀ ਸੰਰਚਨਾ ਫੰਕਸ਼ਨ ਵਿੱਚ ਕੇਂਦ੍ਰਿਤ ਹੁੰਦੀਆਂ ਹਨ।
ਕੈਚਾਂ ਦੀ ਅਣਹੋਂਦ ਦਾ ਮਤਲਬ ਉਹਨਾਂ ਨੂੰ ਐਕਸੈਸ ਕਰਨ ਲਈ ਸਮਕਾਲੀਕਰਨ ਨਾਲ ਜੁੜੇ ਤਾਲੇ ਦੀ ਅਣਹੋਂਦ ਵੀ ਹੈ। ਪਾਠਕ, ਜਿਨ੍ਹਾਂ ਵਿੱਚੋਂ ਇੱਕ ਆਰਬਿਟਰਰੀ ਸੰਖਿਆ ਇੱਕੋ ਸਮੇਂ ਮੌਜੂਦ ਹੋ ਸਕਦੀ ਹੈ, ਡੇਟਾ ਦੇ ਰਸਤੇ ਵਿੱਚ ਇੱਕ ਸਿੰਗਲ ਮਿਊਟੇਕਸ ਦਾ ਸਾਹਮਣਾ ਨਹੀਂ ਕਰਦੇ। ਇਸਦੇ ਕਾਰਨ, CPUs ਦੀ ਸੰਖਿਆ ਦੇ ਰੂਪ ਵਿੱਚ ਰੀਡ ਸਪੀਡ ਵਿੱਚ ਇੱਕ ਆਦਰਸ਼ ਰੇਖਿਕ ਮਾਪਯੋਗਤਾ ਹੈ। LMDB ਵਿੱਚ, ਸਿਰਫ ਸੰਸ਼ੋਧਿਤ ਓਪਰੇਸ਼ਨ ਸਿੰਕ੍ਰੋਨਾਈਜ਼ ਕੀਤੇ ਜਾਂਦੇ ਹਨ। ਇੱਕ ਸਮੇਂ ਵਿੱਚ ਇੱਕ ਹੀ ਲੇਖਕ ਹੋ ਸਕਦਾ ਹੈ।
ਘੱਟੋ-ਘੱਟ ਕੈਚਿੰਗ ਅਤੇ ਸਿੰਕ੍ਰੋਨਾਈਜ਼ੇਸ਼ਨ ਤਰਕ ਕੋਡ ਨੂੰ ਬਹੁ-ਥ੍ਰੈੱਡਡ ਵਾਤਾਵਰਣ ਵਿੱਚ ਕੰਮ ਕਰਨ ਨਾਲ ਜੁੜੀਆਂ ਇੱਕ ਬਹੁਤ ਹੀ ਗੁੰਝਲਦਾਰ ਕਿਸਮ ਦੀਆਂ ਗਲਤੀਆਂ ਤੋਂ ਬਚਾਉਂਦਾ ਹੈ। Usenix OSDI 2014 ਕਾਨਫਰੰਸ ਵਿੱਚ ਦੋ ਦਿਲਚਸਪ ਡਾਟਾਬੇਸ ਅਧਿਐਨ ਸਨ: "ਸਾਰੇ ਫਾਈਲ ਸਿਸਟਮ ਬਰਾਬਰ ਨਹੀਂ ਬਣਾਏ ਗਏ ਹਨ: ਕਰੈਸ਼-ਇਕਸਾਰ ਕਾਰਜਾਂ ਨੂੰ ਤਿਆਰ ਕਰਨ ਦੀ ਜਟਿਲਤਾ 'ਤੇ" и ਮਨੋਰੰਜਨ ਅਤੇ ਲਾਭ ਲਈ ਡੇਟਾਬੇਸ ਨੂੰ ਤਸੀਹੇ ਦੇਣਾ. ਉਹਨਾਂ ਤੋਂ ਤੁਸੀਂ LMDB ਦੀ ਬੇਮਿਸਾਲ ਭਰੋਸੇਯੋਗਤਾ, ਅਤੇ ਟ੍ਰਾਂਜੈਕਸ਼ਨਾਂ ਦੇ ACID ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੇ ਲਗਭਗ ਨਿਰਦੋਸ਼ ਲਾਗੂ ਕਰਨ ਬਾਰੇ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ, ਜੋ ਕਿ ਉਸੇ SQLite ਵਿੱਚ ਇਸ ਨੂੰ ਪਛਾੜਦਾ ਹੈ।
LMDB ਦਾ ਨਿਊਨਤਮਵਾਦ ਇਸ ਦੇ ਕੋਡ ਦੀ ਮਸ਼ੀਨ ਪ੍ਰਤੀਨਿਧਤਾ ਨੂੰ ਨਤੀਜੇ ਵਜੋਂ ਸਪੀਡ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੇ ਨਾਲ ਪ੍ਰੋਸੈਸਰ ਦੇ L1 ਕੈਸ਼ ਵਿੱਚ ਪੂਰੀ ਤਰ੍ਹਾਂ ਰੱਖਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ।

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

ਮੈਮੋਰੀ-ਮੈਪ ਕੀਤੀਆਂ ਫਾਈਲਾਂ ਬਾਰੇ ਆਮ ਜਾਣਕਾਰੀ

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

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

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

ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਵਰਚੁਅਲ ਅਤੇ ਭੌਤਿਕ ਮੈਮੋਰੀ ਨੂੰ ਇੱਕ ਖਾਸ ਆਕਾਰ ਦੇ ਪੰਨਿਆਂ ਵਿੱਚ ਵਿਵਸਥਿਤ ਕਰਦਾ ਹੈ। ਜਿਵੇਂ ਹੀ ਵਰਚੁਅਲ ਮੈਮੋਰੀ ਦੇ ਇੱਕ ਖਾਸ ਪੰਨੇ ਦੀ ਮੰਗ ਹੁੰਦੀ ਹੈ, ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਇਸਨੂੰ ਭੌਤਿਕ ਮੈਮੋਰੀ ਵਿੱਚ ਲੋਡ ਕਰਦਾ ਹੈ ਅਤੇ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਸਾਰਣੀ ਵਿੱਚ ਉਹਨਾਂ ਵਿਚਕਾਰ ਇੱਕ ਪੱਤਰ ਵਿਹਾਰ ਰੱਖਦਾ ਹੈ। ਜੇਕਰ ਕੋਈ ਮੁਫਤ ਸਲਾਟ ਨਹੀਂ ਹਨ, ਤਾਂ ਪਹਿਲਾਂ ਲੋਡ ਕੀਤੇ ਪੰਨਿਆਂ ਵਿੱਚੋਂ ਇੱਕ ਨੂੰ ਡਿਸਕ 'ਤੇ ਕਾਪੀ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਬੇਨਤੀ ਕੀਤੀ ਗਈ ਇੱਕ ਇਸਦੀ ਥਾਂ ਲੈ ਲੈਂਦਾ ਹੈ। ਇਹ ਵਿਧੀ, ਜਿਸ 'ਤੇ ਅਸੀਂ ਜਲਦੀ ਹੀ ਵਾਪਸ ਆਵਾਂਗੇ, ਨੂੰ ਸਵੈਪਿੰਗ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਹੇਠਾਂ ਦਿੱਤੀ ਤਸਵੀਰ ਵਰਣਿਤ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ। ਇਸ 'ਤੇ, ਪਤੇ 0 ਵਾਲਾ ਪੰਨਾ A ਲੋਡ ਕੀਤਾ ਗਿਆ ਸੀ ਅਤੇ ਐਡਰੈੱਸ 4 ਦੇ ਨਾਲ ਮੁੱਖ ਮੈਮੋਰੀ ਪੰਨੇ 'ਤੇ ਰੱਖਿਆ ਗਿਆ ਸੀ। ਇਹ ਤੱਥ ਸੈੱਲ ਨੰਬਰ 0 ਵਿੱਚ ਪੱਤਰ-ਵਿਹਾਰ ਸਾਰਣੀ ਵਿੱਚ ਪ੍ਰਤੀਬਿੰਬਤ ਹੋਇਆ ਸੀ।

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

ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਨੁਕਤਾ ਇਹ ਹੈ ਕਿ LMDB ਡਾਟਾ ਫਾਈਲ ਨੂੰ ਮੂਲ ਰੂਪ ਵਿੱਚ ਲਿਖਣ ਸਿਸਟਮ ਕਾਲ ਵਿਧੀ ਦੁਆਰਾ ਸੰਸ਼ੋਧਿਤ ਕਰਦਾ ਹੈ, ਅਤੇ ਫਾਈਲ ਆਪਣੇ ਆਪ ਹੀ ਰੀਡ-ਓਨਲੀ ਮੋਡ ਵਿੱਚ ਪ੍ਰਦਰਸ਼ਿਤ ਹੁੰਦੀ ਹੈ। ਇਸ ਪਹੁੰਚ ਦੇ ਦੋ ਮਹੱਤਵਪੂਰਨ ਪ੍ਰਭਾਵ ਹਨ.

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

ਦੂਜਾ ਨਤੀਜਾ ਪਹਿਲਾਂ ਹੀ ਆਈਓਐਸ ਲਈ ਖਾਸ ਹੈ. ਨਾ ਤਾਂ ਲੇਖਕ ਅਤੇ ਨਾ ਹੀ ਕੋਈ ਹੋਰ ਸਰੋਤ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਇਸਦਾ ਜ਼ਿਕਰ ਕਰਦੇ ਹਨ, ਪਰ ਇਸਦੇ ਬਿਨਾਂ, LMDB ਇਸ ਮੋਬਾਈਲ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ 'ਤੇ ਚੱਲਣ ਲਈ ਅਯੋਗ ਹੋਵੇਗਾ। ਅਗਲਾ ਭਾਗ ਇਸ ਦੇ ਵਿਚਾਰ ਲਈ ਸਮਰਪਿਤ ਹੈ।

iOS ਵਿੱਚ ਮੈਮੋਰੀ-ਮੈਪ ਕੀਤੀਆਂ ਫਾਈਲਾਂ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ

2018 ਵਿੱਚ, WWDC ਵਿਖੇ ਇੱਕ ਸ਼ਾਨਦਾਰ ਰਿਪੋਰਟ ਆਈ ਸੀ iOS ਮੈਮੋਰੀ ਡੀਪ ਡਾਈਵ. ਇਹ ਦੱਸਦਾ ਹੈ ਕਿ iOS ਵਿੱਚ ਭੌਤਿਕ ਮੈਮੋਰੀ ਵਿੱਚ ਸਥਿਤ ਸਾਰੇ ਪੰਨੇ 3 ਕਿਸਮਾਂ ਵਿੱਚੋਂ ਇੱਕ ਨਾਲ ਸਬੰਧਤ ਹਨ: ਗੰਦੇ, ਸੰਕੁਚਿਤ ਅਤੇ ਸਾਫ਼।

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

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

ਚੰਗੀ ਖ਼ਬਰ, ਜਿਸਦਾ ਪਹਿਲਾਂ ਹੀ ਜ਼ਿਕਰ ਕੀਤਾ ਗਿਆ ਹੈ, ਇਹ ਹੈ ਕਿ LMDB ਮੂਲ ਰੂਪ ਵਿੱਚ ਫਾਈਲਾਂ ਨੂੰ ਅਪਡੇਟ ਕਰਨ ਲਈ mmap ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਨਹੀਂ ਕਰਦਾ ਹੈ। ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਹੈ ਕਿ ਰੈਂਡਰ ਕੀਤੇ ਡੇਟਾ ਨੂੰ iOS ਦੁਆਰਾ ਕਲੀਨ ਮੈਮੋਰੀ ਵਜੋਂ ਸ਼੍ਰੇਣੀਬੱਧ ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ ਮੈਮੋਰੀ ਫੁੱਟਪ੍ਰਿੰਟ ਵਿੱਚ ਯੋਗਦਾਨ ਨਹੀਂ ਪਾਉਂਦਾ ਹੈ। VM ਟਰੈਕਰ ਨਾਮਕ Xcode ਟੂਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਸਦੀ ਪੁਸ਼ਟੀ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ। ਹੇਠਾਂ ਦਿੱਤਾ ਸਕ੍ਰੀਨਸ਼ੌਟ ਓਪਰੇਸ਼ਨ ਦੌਰਾਨ iOS ਕਲਾਉਡ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਵਰਚੁਅਲ ਮੈਮੋਰੀ ਸਥਿਤੀ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। ਸ਼ੁਰੂ ਵਿੱਚ, ਇਸ ਵਿੱਚ 2 LMDB ਉਦਾਹਰਨਾਂ ਸ਼ੁਰੂ ਕੀਤੀਆਂ ਗਈਆਂ ਸਨ। ਪਹਿਲੀ ਨੂੰ ਆਪਣੀ ਫਾਈਲ ਨੂੰ ਵਰਚੁਅਲ ਮੈਮੋਰੀ ਦੇ 1GiB ਨਾਲ ਮੈਪ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੱਤੀ ਗਈ ਸੀ, ਦੂਜੀ - 512MiB. ਇਸ ਤੱਥ ਦੇ ਬਾਵਜੂਦ ਕਿ ਦੋਵੇਂ ਸਟੋਰੇਜ਼ ਇੱਕ ਨਿਸ਼ਚਿਤ ਮਾਤਰਾ ਵਿੱਚ ਨਿਵਾਸੀ ਮੈਮੋਰੀ ਉੱਤੇ ਕਬਜ਼ਾ ਕਰਦੇ ਹਨ, ਇਹਨਾਂ ਵਿੱਚੋਂ ਕੋਈ ਵੀ ਗੰਦੇ ਆਕਾਰ ਵਿੱਚ ਯੋਗਦਾਨ ਨਹੀਂ ਪਾਉਂਦਾ ਹੈ।

ਹੁਣ ਬੁਰੀ ਖ਼ਬਰ ਦਾ ਸਮਾਂ ਆ ਗਿਆ ਹੈ। 64-ਬਿੱਟ ਡੈਸਕਟਾਪ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮਾਂ ਵਿੱਚ ਸਵੈਪ ਮਕੈਨਿਜ਼ਮ ਲਈ ਧੰਨਵਾਦ, ਹਰ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਓਨੀ ਜ਼ਿਆਦਾ ਵਰਚੁਅਲ ਐਡਰੈੱਸ ਸਪੇਸ ਲੈ ਸਕਦੀ ਹੈ ਜਿੰਨੀ ਹਾਰਡ ਡਿਸਕ ਉੱਤੇ ਖਾਲੀ ਸਪੇਸ ਇਸਦੇ ਸੰਭਾਵੀ ਸਵੈਪ ਲਈ ਸਹਾਇਕ ਹੈ। ਆਈਓਐਸ ਵਿੱਚ ਕੰਪਰੈਸ਼ਨ ਨਾਲ ਸਵੈਪ ਨੂੰ ਬਦਲਣ ਨਾਲ ਸਿਧਾਂਤਕ ਅਧਿਕਤਮ ਨੂੰ ਬਹੁਤ ਘੱਟ ਜਾਂਦਾ ਹੈ। ਹੁਣ ਸਾਰੀਆਂ ਜੀਵਿਤ ਪ੍ਰਕਿਰਿਆਵਾਂ ਮੁੱਖ (ਰੈਮ ਪੜ੍ਹੋ) ਮੈਮੋਰੀ ਵਿੱਚ ਫਿੱਟ ਹੋਣੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ, ਅਤੇ ਉਹ ਸਾਰੀਆਂ ਜੋ ਫਿੱਟ ਨਹੀਂ ਹੁੰਦੀਆਂ ਹਨ ਜ਼ਬਰਦਸਤੀ ਸਮਾਪਤੀ ਦੇ ਅਧੀਨ ਹਨ। ਇਹ ਉੱਪਰ ਦੱਸੇ ਅਨੁਸਾਰ ਹੈ ਰਿਪੋਰਟ, ਅਤੇ ਅੰਦਰ ਅਧਿਕਾਰਤ ਦਸਤਾਵੇਜ਼. ਨਤੀਜੇ ਵਜੋਂ, iOS mmap ਦੁਆਰਾ ਵੰਡ ਲਈ ਉਪਲਬਧ ਮੈਮੋਰੀ ਦੀ ਮਾਤਰਾ ਨੂੰ ਬੁਰੀ ਤਰ੍ਹਾਂ ਸੀਮਤ ਕਰਦਾ ਹੈ। ਇਥੇ ਇੱਥੇ ਤੁਸੀਂ ਮੈਮੋਰੀ ਦੀ ਮਾਤਰਾ 'ਤੇ ਅਨੁਭਵੀ ਸੀਮਾਵਾਂ ਨੂੰ ਦੇਖ ਸਕਦੇ ਹੋ ਜੋ ਇਸ ਸਿਸਟਮ ਕਾਲ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਵੱਖ-ਵੱਖ ਡਿਵਾਈਸਾਂ 'ਤੇ ਨਿਰਧਾਰਤ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ। ਸਮਾਰਟਫ਼ੋਨਾਂ ਦੇ ਸਭ ਤੋਂ ਆਧੁਨਿਕ ਮਾਡਲਾਂ 'ਤੇ, ਆਈਓਐਸ 2 ਗੀਗਾਬਾਈਟ ਦੁਆਰਾ ਉਦਾਰ ਹੋ ਗਿਆ ਹੈ, ਅਤੇ ਆਈਪੈਡ ਦੇ ਚੋਟੀ ਦੇ ਸੰਸਕਰਣਾਂ 'ਤੇ - 4 ਦੁਆਰਾ. ਅਭਿਆਸ ਵਿੱਚ, ਬੇਸ਼ਕ, ਤੁਹਾਨੂੰ ਸਭ ਤੋਂ ਘੱਟ ਸਮਰਥਿਤ ਡਿਵਾਈਸ ਮਾਡਲਾਂ 'ਤੇ ਧਿਆਨ ਕੇਂਦਰਿਤ ਕਰਨਾ ਪਵੇਗਾ, ਜਿੱਥੇ ਸਭ ਕੁਝ ਬਹੁਤ ਉਦਾਸ ਹੈ. ਇਸ ਤੋਂ ਵੀ ਬਦਤਰ, VM ਟਰੈਕਰ ਵਿੱਚ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਮੈਮੋਰੀ ਸਥਿਤੀ ਨੂੰ ਦੇਖਦੇ ਹੋਏ, ਤੁਸੀਂ ਦੇਖੋਗੇ ਕਿ LMDB ਸਿਰਫ ਇੱਕ ਦਾਅਵਾ ਕਰਨ ਵਾਲੀ ਮੈਮੋਰੀ-ਮੈਪਡ ਮੈਮੋਰੀ ਤੋਂ ਬਹੁਤ ਦੂਰ ਹੈ। ਸਿਸਟਮ ਅਲੋਕੇਟਰਾਂ, ਸਰੋਤ ਫਾਈਲਾਂ, ਚਿੱਤਰ ਫਰੇਮਵਰਕ, ਅਤੇ ਹੋਰ ਛੋਟੇ ਸ਼ਿਕਾਰੀਆਂ ਦੁਆਰਾ ਚੰਗੇ ਭਾਗਾਂ ਨੂੰ ਖਾਧਾ ਜਾਂਦਾ ਹੈ।

ਕਲਾਊਡ ਵਿੱਚ ਪ੍ਰਯੋਗਾਂ ਦੇ ਨਤੀਜਿਆਂ ਦੇ ਆਧਾਰ 'ਤੇ, ਅਸੀਂ LMDB ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਮੈਮੋਰੀ ਦੇ ਹੇਠਲੇ ਸਮਝੌਤਾ ਮੁੱਲਾਂ 'ਤੇ ਆਏ ਹਾਂ: 384-ਬਿੱਟ ਡਿਵਾਈਸਾਂ ਲਈ 32 ਮੈਗਾਬਾਈਟ ਅਤੇ 768-ਬਿੱਟ ਡਿਵਾਈਸਾਂ ਲਈ 64। ਇਸ ਵੌਲਯੂਮ ਦੀ ਵਰਤੋਂ ਹੋਣ ਤੋਂ ਬਾਅਦ, ਕੋਈ ਵੀ ਸੰਸ਼ੋਧਨ ਕਾਰਜ ਕੋਡ ਨਾਲ ਪੂਰਾ ਹੋਣਾ ਸ਼ੁਰੂ ਹੋ ਜਾਂਦਾ ਹੈ MDB_MAP_FULL. ਅਸੀਂ ਆਪਣੀ ਨਿਗਰਾਨੀ ਵਿੱਚ ਅਜਿਹੀਆਂ ਗਲਤੀਆਂ ਦੇਖਦੇ ਹਾਂ, ਪਰ ਉਹ ਇਸ ਪੜਾਅ 'ਤੇ ਨਜ਼ਰਅੰਦਾਜ਼ ਕਰਨ ਲਈ ਬਹੁਤ ਘੱਟ ਹਨ।

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

3.2 ਵ੍ਹੇਲ #2. ਬੀ+-ਰੁੱਖ

ਕੁੰਜੀ-ਮੁੱਲ ਸਟੋਰ ਦੇ ਸਿਖਰ 'ਤੇ ਟੇਬਲਾਂ ਦੀ ਨਕਲ ਕਰਨ ਲਈ, ਹੇਠਾਂ ਦਿੱਤੇ ਓਪਰੇਸ਼ਨ ਇਸਦੇ API ਵਿੱਚ ਮੌਜੂਦ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ:

ਇੱਕ ਨਵਾਂ ਤੱਤ ਸ਼ਾਮਲ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ।
ਦਿੱਤੀ ਕੁੰਜੀ ਦੇ ਨਾਲ ਇੱਕ ਤੱਤ ਦੀ ਖੋਜ ਕਰੋ।
ਇੱਕ ਤੱਤ ਨੂੰ ਮਿਟਾਉਣਾ।
ਮੁੱਖ ਅੰਤਰਾਲਾਂ ਨੂੰ ਉਹਨਾਂ ਦੇ ਲੜੀਬੱਧ ਕ੍ਰਮ ਵਿੱਚ ਦੁਹਰਾਓ।

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

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

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

ਇਸ ਤਰ੍ਹਾਂ:

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

LMDB ਡਾਟਾ ਸਟੋਰ ਕਰਨ ਲਈ B- ਟ੍ਰੀ ਦੇ ਇੱਕ ਰੂਪ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਜਿਸਨੂੰ B+ ਟ੍ਰੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਉਪਰੋਕਤ ਚਿੱਤਰ ਤਿੰਨ ਕਿਸਮਾਂ ਦੇ ਨੋਡਾਂ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ਜੋ ਇਸ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨ:

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

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

ਪੇਜ ਨੋਡਸ ਦੀ ਅੰਦਰੂਨੀ ਸਮੱਗਰੀ ਨਾਲ ਨਜਿੱਠਣ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਅੱਗੇ ਦਿੱਤੇ ਰੂਪ ਵਿੱਚ ਇੱਕ ਸਰਲ ਤਰੀਕੇ ਨਾਲ LMDB ਬੀ-ਟ੍ਰੀ ਨੂੰ ਦਰਸਾਵਾਂਗੇ।

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

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

3.3 ਵ੍ਹੇਲ #3. ਕਾਪੀ-ਆਨ-ਲਿਖਣ

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

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

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

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

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

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

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

ਇੱਥੇ ਮੈਮੋਰੀ-ਮੈਪਡ ਫਾਈਲਾਂ ਦੇ ਭਾਗ ਨੂੰ ਯਾਦ ਕਰਨਾ ਬੇਲੋੜਾ ਨਹੀਂ ਹੋਵੇਗਾ। ਅਜਿਹਾ ਲਗਦਾ ਹੈ ਕਿ ਵਰਚੁਅਲ ਮੈਮੋਰੀ ਦੀ ਵਾਧੂ ਖਪਤ ਸਾਨੂੰ ਬਹੁਤ ਜ਼ਿਆਦਾ ਪਰੇਸ਼ਾਨ ਨਹੀਂ ਕਰਨੀ ਚਾਹੀਦੀ, ਕਿਉਂਕਿ ਇਹ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਮੈਮੋਰੀ ਫੁੱਟਪ੍ਰਿੰਟ ਵਿੱਚ ਯੋਗਦਾਨ ਨਹੀਂ ਪਾਉਂਦੀ ਹੈ। ਹਾਲਾਂਕਿ, ਉਸੇ ਸਮੇਂ, ਇਹ ਨੋਟ ਕੀਤਾ ਗਿਆ ਸੀ ਕਿ iOS ਇਸ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਵਿੱਚ ਬਹੁਤ ਕਠੋਰ ਹੈ, ਅਤੇ ਅਸੀਂ ਮਾਸਟਰ ਦੇ ਮੋਢੇ ਤੋਂ ਸਰਵਰ ਜਾਂ ਡੈਸਕਟੌਪ 'ਤੇ 1 ਟੇਰਾਬਾਈਟ LMDB ਖੇਤਰ ਪ੍ਰਦਾਨ ਨਹੀਂ ਕਰ ਸਕਦੇ ਹਾਂ ਅਤੇ ਇਸ ਵਿਸ਼ੇਸ਼ਤਾ ਬਾਰੇ ਬਿਲਕੁਲ ਵੀ ਨਹੀਂ ਸੋਚ ਸਕਦੇ ਹਾਂ। ਜਦੋਂ ਸੰਭਵ ਹੋਵੇ, ਤੁਹਾਨੂੰ ਲੈਣ-ਦੇਣ ਦੇ ਜੀਵਨ ਕਾਲ ਨੂੰ ਜਿੰਨਾ ਸੰਭਵ ਹੋ ਸਕੇ ਛੋਟਾ ਰੱਖਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ।

4. ਕੁੰਜੀ-ਮੁੱਲ API ਦੇ ਸਿਖਰ 'ਤੇ ਇੱਕ ਡਾਟਾ ਸਕੀਮਾ ਡਿਜ਼ਾਈਨ ਕਰਨਾ

ਆਉ LMDB ਦੁਆਰਾ ਪ੍ਰਦਾਨ ਕੀਤੇ ਗਏ ਮੂਲ ਐਬਸਟਰੈਕਸ਼ਨਾਂ ਨੂੰ ਦੇਖ ਕੇ API ਨੂੰ ਪਾਰਸ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰੀਏ: ਵਾਤਾਵਰਣ ਅਤੇ ਡੇਟਾਬੇਸ, ਕੁੰਜੀਆਂ ਅਤੇ ਮੁੱਲ, ਲੈਣ-ਦੇਣ ਅਤੇ ਕਰਸਰ।

ਕੋਡ ਸੂਚੀਆਂ ਬਾਰੇ ਇੱਕ ਨੋਟ

LMDB ਜਨਤਕ API ਵਿੱਚ ਸਾਰੇ ਫੰਕਸ਼ਨ ਇੱਕ ਗਲਤੀ ਕੋਡ ਦੇ ਰੂਪ ਵਿੱਚ ਉਹਨਾਂ ਦੇ ਕੰਮ ਦਾ ਨਤੀਜਾ ਵਾਪਸ ਕਰਦੇ ਹਨ, ਪਰ ਸਾਰੀਆਂ ਅਗਲੀਆਂ ਸੂਚੀਆਂ ਵਿੱਚ ਸੰਖੇਪਤਾ ਲਈ ਇਸਦੀ ਜਾਂਚ ਨੂੰ ਛੱਡ ਦਿੱਤਾ ਗਿਆ ਹੈ। ਅਭਿਆਸ ਵਿੱਚ, ਅਸੀਂ ਰਿਪੋਜ਼ਟਰੀ ਨਾਲ ਇੰਟਰੈਕਟ ਕਰਨ ਲਈ ਆਪਣੇ ਖੁਦ ਦੇ ਕੋਡ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ। ਕਾਂਟਾ C++ ਰੈਪਰ lmdbxx, ਜਿਸ ਵਿੱਚ ਤਰੁੱਟੀਆਂ C++ ਅਪਵਾਦਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਸਾਹਮਣੇ ਆਉਂਦੀਆਂ ਹਨ।

LMDB ਨੂੰ ਇੱਕ iOS ਜਾਂ macOS ਪ੍ਰੋਜੈਕਟ ਨਾਲ ਜੋੜਨ ਦੇ ਸਭ ਤੋਂ ਤੇਜ਼ ਤਰੀਕੇ ਵਜੋਂ, ਮੈਂ ਆਪਣਾ CocoaPod ਪੇਸ਼ ਕਰਦਾ ਹਾਂ POSLMDB.

4.1 ਬੁਨਿਆਦੀ ਐਬਸਟਰੈਕਸ਼ਨ

ਵਾਤਾਵਰਣ

ਬਣਤਰ MDB_env ਇਹ LMDB ਦੀ ਅੰਦਰੂਨੀ ਸਥਿਤੀ ਦਾ ਭੰਡਾਰ ਹੈ। ਪ੍ਰੀਫਿਕਸਡ ਫੰਕਸ਼ਨਾਂ ਦਾ ਪਰਿਵਾਰ mdb_env ਤੁਹਾਨੂੰ ਇਸ ਦੀਆਂ ਕੁਝ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਸੰਰਚਿਤ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਸਧਾਰਨ ਮਾਮਲੇ ਵਿੱਚ, ਇੰਜਣ ਦੀ ਸ਼ੁਰੂਆਤ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ.

mdb_env_create(env);
mdb_env_set_map_size(*env, 1024 * 1024 * 512)
mdb_env_open(*env, path.UTF8String, MDB_NOTLS, 0664);

Mail.ru ਕਲਾਉਡ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ, ਅਸੀਂ ਸਿਰਫ ਦੋ ਪੈਰਾਮੀਟਰਾਂ ਲਈ ਡਿਫੌਲਟ ਮੁੱਲ ਬਦਲੇ ਹਨ।

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

ਦੂਜਾ ਪੈਰਾਮੀਟਰ, ਜਿਸਦਾ ਮੂਲ ਮੁੱਲ ਸਾਡੇ ਅਨੁਕੂਲ ਨਹੀਂ ਸੀ, ਥਰਿੱਡ ਸੁਰੱਖਿਆ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਦੇ ਮਕੈਨਿਕਸ ਨੂੰ ਨਿਯੰਤ੍ਰਿਤ ਕਰਦਾ ਹੈ। ਬਦਕਿਸਮਤੀ ਨਾਲ, ਘੱਟੋ-ਘੱਟ ਆਈਓਐਸ 10 ਵਿੱਚ, ਥਰਿੱਡ ਸਥਾਨਕ ਸਟੋਰੇਜ ਸਹਾਇਤਾ ਨਾਲ ਸਮੱਸਿਆਵਾਂ ਹਨ। ਇਸ ਕਾਰਨ ਕਰਕੇ, ਉਪਰੋਕਤ ਉਦਾਹਰਨ ਵਿੱਚ, ਰਿਪੋਜ਼ਟਰੀ ਫਲੈਗ ਨਾਲ ਖੋਲ੍ਹਿਆ ਗਿਆ ਹੈ MDB_NOTLS. ਇਸ ਦੇ ਨਾਲ, ਇਸ ਨੂੰ ਵੀ ਲੋੜ ਹੈ ਕਾਂਟਾ C++ ਰੈਪਰ lmdbxxਇਸ ਗੁਣ ਨਾਲ ਅਤੇ ਇਸ ਵਿੱਚ ਵੇਰੀਏਬਲ ਕੱਟਣ ਲਈ।

ਡਾਟਾਬੇਸ

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

MDB_txn *txn;
MDB_dbi dbi;
mdb_txn_begin(env, NULL, MDB_RDONLY, &txn);
mdb_dbi_open(txn, NULL, MDB_CREATE, &dbi);
mdb_txn_abort(txn);

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

ਕੁੰਜੀਆਂ ਅਤੇ ਮੁੱਲ

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

typedef struct MDB_val {
    size_t mv_size;
    void *mv_data;
} MDB_val;

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

ਟ੍ਰਾਂਜੈਕਸ਼ਨਾਂ

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

ਸਾਰੀਆਂ ਬੁਨਿਆਦੀ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਲਈ ਸਮਰਥਨ ACIDਮੁੱਖ ਸ਼ਬਦ: ਪਰਮਾਣੂ, ਇਕਸਾਰਤਾ, ਅਲੱਗ-ਥਲੱਗਤਾ ਅਤੇ ਭਰੋਸੇਯੋਗਤਾ। ਮੈਂ ਮਦਦ ਨਹੀਂ ਕਰ ਸਕਦਾ ਪਰ ਨੋਟ ਕਰੋ ਕਿ ਮੈਕੋਸ ਅਤੇ ਆਈਓਐਸ 'ਤੇ ਟਿਕਾਊਤਾ ਦੇ ਮਾਮਲੇ ਵਿੱਚ MDBX ਵਿੱਚ ਇੱਕ ਬੱਗ ਫਿਕਸ ਕੀਤਾ ਗਿਆ ਹੈ। ਤੁਸੀਂ ਉਹਨਾਂ ਵਿੱਚ ਹੋਰ ਪੜ੍ਹ ਸਕਦੇ ਹੋ README.
ਮਲਟੀਥ੍ਰੈਡਿੰਗ ਦੀ ਪਹੁੰਚ ਨੂੰ "ਸਿੰਗਲ ਲੇਖਕ / ਮਲਟੀਪਲ ਰੀਡਰ" ਸਕੀਮ ਦੁਆਰਾ ਦਰਸਾਇਆ ਗਿਆ ਹੈ। ਲੇਖਕ ਇੱਕ ਦੂਜੇ ਨੂੰ ਬਲਾਕ ਕਰਦੇ ਹਨ, ਪਰ ਉਹ ਪਾਠਕਾਂ ਨੂੰ ਨਹੀਂ ਰੋਕਦੇ। ਪਾਠਕ ਲੇਖਕਾਂ ਜਾਂ ਇੱਕ ਦੂਜੇ ਨੂੰ ਬਲੌਕ ਨਹੀਂ ਕਰਦੇ।
ਨੇਸਟਡ ਟ੍ਰਾਂਜੈਕਸ਼ਨਾਂ ਲਈ ਸਮਰਥਨ।
ਮਲਟੀਵਰਜ਼ਨ ਸਹਿਯੋਗ.

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

ਇੱਕ ਟੈਸਟ ਐਂਟਰੀ ਜੋੜ ਰਿਹਾ ਹੈ

MDB_env *env;
MDB_dbi dbi;
MDB_txn *txn;

mdb_env_create(&env);
mdb_env_open(env, "./testdb", MDB_NOTLS, 0664);

mdb_txn_begin(env, NULL, 0, &txn);
mdb_dbi_open(txn, NULL, 0, &dbi);
mdb_txn_abort(txn);

char k = 'k';
MDB_val key;
key.mv_size = sizeof(k);
key.mv_data = (void *)&k;

int v = 997;
MDB_val value;
value.mv_size = sizeof(v);
value.mv_data = (void *)&v;

mdb_txn_begin(env, NULL, 0, &txn);
mdb_put(txn, dbi, &key, &value, MDB_NOOVERWRITE);
mdb_txn_commit(txn);

MDB_txn *txn1, *txn2, *txn3;
MDB_val val;

// Открываем 2 транзакции, каждая из которых смотрит
// на версию базы данных с одной записью.
mdb_txn_begin(env, NULL, 0, &txn1); // read-write
mdb_txn_begin(env, NULL, MDB_RDONLY, &txn2); // read-only

// В рамках первой транзакции удаляем из базы данных существующую в ней запись.
mdb_del(txn1, dbi, &key, NULL);
// Фиксируем удаление.
mdb_txn_commit(txn1);

// Открываем третью транзакцию, которая смотрит на
// актуальную версию базы данных, где записи уже нет.
mdb_txn_begin(env, NULL, MDB_RDONLY, &txn3);
// Убеждаемся, что запись по искомому ключу уже не существует.
assert(mdb_get(txn3, dbi, &key, &val) == MDB_NOTFOUND);
// Завершаем транзакцию.
mdb_txn_abort(txn3);

// Убеждаемся, что в рамках второй транзакции, открытой на момент
// существования записи в базе данных, её всё ещё можно найти по ключу.
assert(mdb_get(txn2, dbi, &key, &val) == MDB_SUCCESS);
// Проверяем, что по ключу получен не абы какой мусор, а валидные данные.
assert(*(int *)val.mv_data == 997);
// Завершаем транзакцию, работающей хоть и с устаревшей, но консистентной базой данных.
mdb_txn_abort(txn2);

ਵਿਕਲਪਿਕ ਤੌਰ 'ਤੇ, ਮੈਂ SQLite ਨਾਲ ਉਹੀ ਚਾਲ ਅਜ਼ਮਾਉਣ ਦੀ ਸਿਫਾਰਸ਼ ਕਰਦਾ ਹਾਂ ਅਤੇ ਦੇਖੋ ਕਿ ਕੀ ਹੁੰਦਾ ਹੈ.

ਮਲਟੀਵਰਜ਼ਨਿੰਗ ਇੱਕ iOS ਡਿਵੈਲਪਰ ਦੇ ਜੀਵਨ ਵਿੱਚ ਬਹੁਤ ਵਧੀਆ ਲਾਭ ਲਿਆਉਂਦਾ ਹੈ। ਇਸ ਸੰਪੱਤੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ, ਤੁਸੀਂ ਉਪਭੋਗਤਾ ਅਨੁਭਵ ਦੇ ਵਿਚਾਰਾਂ ਦੇ ਆਧਾਰ 'ਤੇ ਸਕ੍ਰੀਨ ਫਾਰਮਾਂ ਲਈ ਡਾਟਾ ਸਰੋਤ ਅੱਪਡੇਟ ਦਰ ਨੂੰ ਆਸਾਨੀ ਨਾਲ ਅਤੇ ਕੁਦਰਤੀ ਤੌਰ 'ਤੇ ਵਿਵਸਥਿਤ ਕਰ ਸਕਦੇ ਹੋ। ਉਦਾਹਰਨ ਲਈ, ਆਓ Mail.ru ਕਲਾਉਡ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਅਜਿਹੀ ਵਿਸ਼ੇਸ਼ਤਾ ਨੂੰ ਸਿਸਟਮ ਮੀਡੀਆ ਗੈਲਰੀ ਤੋਂ ਆਟੋਲੋਡਿੰਗ ਸਮਗਰੀ ਦੇ ਰੂਪ ਵਿੱਚ ਲੈਂਦੇ ਹਾਂ। ਇੱਕ ਚੰਗੇ ਕੁਨੈਕਸ਼ਨ ਦੇ ਨਾਲ, ਕਲਾਇੰਟ ਸਰਵਰ ਵਿੱਚ ਪ੍ਰਤੀ ਸਕਿੰਟ ਕਈ ਫੋਟੋਆਂ ਜੋੜਨ ਦੇ ਯੋਗ ਹੁੰਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਹਰੇਕ ਡਾਊਨਲੋਡ ਤੋਂ ਬਾਅਦ ਅੱਪਡੇਟ ਕਰਦੇ ਹੋ UICollectionView ਉਪਭੋਗਤਾ ਦੇ ਕਲਾਉਡ ਵਿੱਚ ਮੀਡੀਆ ਸਮੱਗਰੀ ਦੇ ਨਾਲ, ਤੁਸੀਂ ਇਸ ਪ੍ਰਕਿਰਿਆ ਦੌਰਾਨ ਲਗਭਗ 60 fps ਅਤੇ ਨਿਰਵਿਘਨ ਸਕ੍ਰੌਲਿੰਗ ਨੂੰ ਭੁੱਲ ਸਕਦੇ ਹੋ। ਅਕਸਰ ਸਕ੍ਰੀਨ ਅਪਡੇਟਾਂ ਨੂੰ ਰੋਕਣ ਲਈ, ਤੁਹਾਨੂੰ ਕਿਸੇ ਤਰ੍ਹਾਂ ਆਧਾਰ ਵਿੱਚ ਡੇਟਾ ਤਬਦੀਲੀ ਦੀ ਦਰ ਨੂੰ ਸੀਮਤ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ UICollectionViewDataSource.

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

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

ਕਰਸਰ

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

4.2 ਟੇਬਲ ਮਾਡਲਿੰਗ

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

ਸਾਰਣੀ ਸਕੀਮਾ

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

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

ਸੀਰੀਅਲਾਈਜ਼ਿੰਗ ਕੁੰਜੀਆਂ ਅਤੇ ਮੁੱਲ

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

typedef struct NodeKey {
    EntityId parentId;
    uint8_t type;
    uint8_t nameBuffer[256];
} NodeKey;

ਨੂੰ ਬਚਾਉਣ ਲਈ NodeKey ਵਸਤੂ ਵਿੱਚ ਸਟੋਰੇਜ਼ ਦੀ ਲੋੜ ਹੈ MDB_val ਸੰਰਚਨਾ ਦੀ ਸ਼ੁਰੂਆਤ ਦੇ ਪਤੇ 'ਤੇ ਡੇਟਾ ਲਈ ਪੁਆਇੰਟਰ ਦੀ ਸਥਿਤੀ ਕਰੋ, ਅਤੇ ਫੰਕਸ਼ਨ ਨਾਲ ਉਹਨਾਂ ਦੇ ਆਕਾਰ ਦੀ ਗਣਨਾ ਕਰੋ sizeof.

MDB_val serialize(NodeKey * const key) {
    return MDB_val {
        .mv_size = sizeof(NodeKey),
        .mv_data = (void *)key
    };
}

ਡੇਟਾਬੇਸ ਚੋਣ ਮਾਪਦੰਡ ਦੇ ਪਹਿਲੇ ਅਧਿਆਇ ਵਿੱਚ, ਮੈਂ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਚੋਣ ਕਾਰਕ ਵਜੋਂ CRUD ਕਾਰਜਾਂ ਦੇ ਹਿੱਸੇ ਵਜੋਂ ਗਤੀਸ਼ੀਲ ਵੰਡ ਨੂੰ ਘੱਟ ਕਰਨ ਦਾ ਜ਼ਿਕਰ ਕੀਤਾ ਹੈ। ਫੰਕਸ਼ਨ ਕੋਡ serialize ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਕਿਵੇਂ, LMDB ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਉਹਨਾਂ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਟਾਲਿਆ ਜਾ ਸਕਦਾ ਹੈ ਜਦੋਂ ਡੇਟਾਬੇਸ ਵਿੱਚ ਨਵੇਂ ਰਿਕਾਰਡ ਪਾਏ ਜਾਂਦੇ ਹਨ। ਸਰਵਰ ਤੋਂ ਬਾਈਟਾਂ ਦੀ ਆਉਣ ਵਾਲੀ ਐਰੇ ਪਹਿਲਾਂ ਸਟੈਕ ਢਾਂਚੇ ਵਿੱਚ ਬਦਲ ਜਾਂਦੀ ਹੈ, ਅਤੇ ਫਿਰ ਉਹਨਾਂ ਨੂੰ ਮਾਮੂਲੀ ਤੌਰ 'ਤੇ ਸਟੋਰੇਜ ਵਿੱਚ ਡੰਪ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਧਿਆਨ ਵਿੱਚ ਰੱਖਦੇ ਹੋਏ ਕਿ LMDB ਦੇ ਅੰਦਰ ਕੋਈ ਗਤੀਸ਼ੀਲ ਵੰਡ ਵੀ ਨਹੀਂ ਹੈ, ਤੁਸੀਂ iOS ਦੇ ਮਾਪਦੰਡਾਂ ਦੁਆਰਾ ਇੱਕ ਸ਼ਾਨਦਾਰ ਸਥਿਤੀ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ - ਨੈਟਵਰਕ ਤੋਂ ਡਿਸਕ ਤੱਕ ਡੇਟਾ ਦੇ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਸਿਰਫ ਸਟੈਕ ਮੈਮੋਰੀ ਦੀ ਵਰਤੋਂ ਕਰੋ!

ਬਾਈਨਰੀ ਤੁਲਨਾਕਾਰ ਨਾਲ ਕੁੰਜੀਆਂ ਦਾ ਆਰਡਰ ਕਰਨਾ

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

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

// value (hex dump)
000 (0000)
256 (0001)
001 (0100)
257 (0101)
...
254 (fe00)
510 (fe01)
255 (ff00)
511 (ff01)

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

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

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

ਇੱਕ ਬਾਹਰੀ ਤੁਲਨਾਕਾਰ ਦੁਆਰਾ ਮੁੱਖ ਆਰਡਰਿੰਗ

ਮੁੱਖ ਤੁਲਨਾ ਤਰਕ ਇੱਕ ਬਾਈਨਰੀ ਤੁਲਨਾਕਾਰ ਲਈ ਬਹੁਤ ਗੁੰਝਲਦਾਰ ਹੋ ਸਕਦਾ ਹੈ। ਬਹੁਤ ਸਾਰੇ ਕਾਰਨਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ ਢਾਂਚੇ ਦੇ ਅੰਦਰ ਤਕਨੀਕੀ ਖੇਤਰਾਂ ਦੀ ਮੌਜੂਦਗੀ. ਮੈਂ ਉਹਨਾਂ ਦੀ ਮੌਜੂਦਗੀ ਨੂੰ ਇੱਕ ਡਾਇਰੈਕਟਰੀ ਤੱਤ ਲਈ ਸਾਡੇ ਲਈ ਪਹਿਲਾਂ ਤੋਂ ਜਾਣੀ ਜਾਂਦੀ ਕੁੰਜੀ ਦੀ ਉਦਾਹਰਣ 'ਤੇ ਦਰਸਾਵਾਂਗਾ।

typedef struct NodeKey {
    EntityId parentId;
    uint8_t type;
    uint8_t nameBuffer[256];
} NodeKey;

ਇਸਦੀ ਸਾਰੀ ਸਾਦਗੀ ਲਈ, ਬਹੁਤ ਸਾਰੇ ਮਾਮਲਿਆਂ ਵਿੱਚ ਇਹ ਬਹੁਤ ਜ਼ਿਆਦਾ ਮੈਮੋਰੀ ਦੀ ਖਪਤ ਕਰਦਾ ਹੈ. ਟਾਈਟਲ ਬਫਰ 256 ਬਾਈਟ ਹੈ, ਹਾਲਾਂਕਿ ਔਸਤਨ ਫਾਈਲ ਅਤੇ ਫੋਲਡਰ ਦੇ ਨਾਂ ਕਦੇ-ਕਦਾਈਂ 20-30 ਅੱਖਰਾਂ ਤੋਂ ਵੱਧ ਹੁੰਦੇ ਹਨ।

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

typedef struct NodeKey {
    EntityId parentId;
    uint8_t type;
    uint8_t nameLength;
    uint8_t nameBuffer[256];
} NodeKey;

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

MDB_val serialize(NodeKey * const key) {
    return MDB_val {
        .mv_size = offsetof(NodeKey, nameBuffer) + key->nameLength,
        .mv_data = (void *)key
    };
}

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

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

int compare(MDB_val * const a, MDB_val * const b) {
    NodeKey * const aKey = (NodeKey * const)a->mv_data;
    NodeKey * const bKey = (NodeKey * const)b->mv_data;
    return // ...
}

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

ਮੁੱਲ ਸੀਰੀਅਲਾਈਜ਼ੇਸ਼ਨ

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

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

NSData *data = serialize(object);
MDB_val value = {
    .mv_size = data.length,
    .mv_data = (void *)data.bytes
};

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

C ਭਾਸ਼ਾ ਵਿੱਚ ਇਸਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ, ਵਾਰਸਾਂ ਦੇ ਖਾਸ ਖੇਤਰਾਂ ਨੂੰ ਵੱਖ-ਵੱਖ ਢਾਂਚੇ ਵਿੱਚ ਲਿਆ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਉਹਨਾਂ ਦੇ ਅਧਾਰ ਦੇ ਨਾਲ ਉਹਨਾਂ ਦਾ ਸਬੰਧ ਯੂਨੀਅਨ ਕਿਸਮ ਦੇ ਇੱਕ ਖੇਤਰ ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਯੂਨੀਅਨ ਦੀ ਅਸਲ ਸਮੱਗਰੀ ਨੂੰ ਕਿਸਮ ਦੇ ਤਕਨੀਕੀ ਗੁਣ ਦੁਆਰਾ ਨਿਰਦਿਸ਼ਟ ਕੀਤਾ ਗਿਆ ਹੈ.

typedef struct NodeValue {
    EntityId localId;
    EntityType type;
    union {
        FileInfo file;
        DirectoryInfo directory;
    } info;
    uint8_t nameLength;
    uint8_t nameBuffer[256];
} NodeValue;

ਰਿਕਾਰਡ ਜੋੜਨਾ ਅਤੇ ਅੱਪਡੇਟ ਕਰਨਾ

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

// key и value имеют тип MDB_val
mdb_put(..., &key, &value, MDB_NOOVERWRITE);

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

ਰੀਡਿੰਗ ਰਿਕਾਰਡਸ

LMDB ਵਿੱਚ ਰਿਕਾਰਡ ਪੜ੍ਹਨ ਲਈ ਫੰਕਸ਼ਨ ਹੈ mdb_get. ਜੇਕਰ ਕੁੰਜੀ-ਮੁੱਲ ਦੇ ਜੋੜੇ ਨੂੰ ਪਹਿਲਾਂ ਡੰਪ ਕੀਤੇ ਢਾਂਚੇ ਦੁਆਰਾ ਦਰਸਾਇਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਹ ਵਿਧੀ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ।

NodeValue * const readNode(..., NodeKey * const key) {
    MDB_val rawKey = serialize(key);
    MDB_val rawValue;
    mdb_get(..., &rawKey, &rawValue);
    return (NodeValue * const)rawValue.mv_data;
}

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

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

ਅੰਤ ਵਿੱਚ, ਇੱਕ ਹੋਰ ਵਿਸ਼ੇਸ਼ਤਾ ਇੰਨੀ ਧੋਖੇਬਾਜ਼ ਹੈ ਕਿ ਇਸਦੇ ਤੱਤ ਦਾ ਖੁਲਾਸਾ ਕੇਵਲ ਇੱਕ ਹੋਰ ਬਿੰਦੂ ਵਿੱਚ ਫਿੱਟ ਨਹੀਂ ਬੈਠਦਾ। ਬੀ-ਟ੍ਰੀ ਦੇ ਅਧਿਆਇ ਵਿੱਚ, ਮੈਂ ਮੈਮੋਰੀ ਵਿੱਚ ਇਸਦੇ ਪੰਨਿਆਂ ਦੇ ਸੰਗਠਨ ਦਾ ਇੱਕ ਚਿੱਤਰ ਦਿੱਤਾ ਹੈ। ਇਸ ਤੋਂ ਇਹ ਪਤਾ ਚਲਦਾ ਹੈ ਕਿ ਸੀਰੀਅਲਾਈਜ਼ਡ ਡੇਟਾ ਦੇ ਨਾਲ ਬਫਰ ਦੀ ਸ਼ੁਰੂਆਤ ਦਾ ਪਤਾ ਬਿਲਕੁਲ ਮਨਮਾਨੀ ਹੋ ਸਕਦਾ ਹੈ। ਇਸਦੇ ਕਾਰਨ, ਉਹਨਾਂ ਨੂੰ ਸੰਕੇਤਕ, ਬਣਤਰ ਵਿੱਚ ਪ੍ਰਾਪਤ ਕੀਤਾ MDB_val ਅਤੇ ਕਿਸੇ ਢਾਂਚੇ ਦੇ ਪੁਆਇੰਟਰ ਨੂੰ ਕਾਸਟ ਕਰਨਾ ਆਮ ਤੌਰ 'ਤੇ ਅਲਾਈਨ ਹੁੰਦਾ ਹੈ। ਉਸੇ ਸਮੇਂ, ਕੁਝ ਚਿਪਸ ਦੇ ਆਰਕੀਟੈਕਚਰ (ਆਈਓਐਸ ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਇਹ armv7 ਹੈ) ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਕਿ ਕਿਸੇ ਵੀ ਡੇਟਾ ਦਾ ਪਤਾ ਇੱਕ ਮਸ਼ੀਨ ਸ਼ਬਦ ਦੇ ਆਕਾਰ ਦਾ ਮਲਟੀਪਲ ਹੋਵੇ, ਜਾਂ, ਦੂਜੇ ਸ਼ਬਦਾਂ ਵਿੱਚ, ਸਿਸਟਮ ਦੀ ਬਿੱਟਨੇਸ (armv7 ਲਈ, ਇਹ 32 ਬਿੱਟ ਹੈ)। ਦੂਜੇ ਸ਼ਬਦਾਂ ਵਿੱਚ, ਇੱਕ ਓਪਰੇਸ਼ਨ ਵਰਗਾ *(int *foo)0x800002 ਉਹਨਾਂ 'ਤੇ ਬਚਣ ਦੇ ਬਰਾਬਰ ਹੈ ਅਤੇ ਇੱਕ ਫੈਸਲੇ ਦੇ ਨਾਲ ਫਾਂਸੀ ਦੀ ਅਗਵਾਈ ਕਰਦਾ ਹੈ EXC_ARM_DA_ALIGN. ਅਜਿਹੀ ਉਦਾਸ ਕਿਸਮਤ ਤੋਂ ਬਚਣ ਦੇ ਦੋ ਤਰੀਕੇ ਹਨ.

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

int compare(MDB_val * const a, MDB_val * const b) {
    NodeKey aKey, bKey;
    memcpy(&aKey, a->mv_data, a->mv_size);
    memcpy(&bKey, b->mv_data, b->mv_size);
    return // ...
}

ਇੱਕ ਵਿਕਲਪਿਕ ਤਰੀਕਾ ਇਹ ਹੈ ਕਿ ਕੰਪਾਈਲਰ ਨੂੰ ਪਹਿਲਾਂ ਹੀ ਸੂਚਿਤ ਕੀਤਾ ਜਾਵੇ ਕਿ ਇੱਕ ਕੁੰਜੀ ਅਤੇ ਮੁੱਲ ਵਾਲੇ ਢਾਂਚੇ ਇੱਕ ਵਿਸ਼ੇਸ਼ਤਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਕਸਾਰ ਨਹੀਂ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ aligned(1). ARM 'ਤੇ ਵੀ ਇਹੀ ਪ੍ਰਭਾਵ ਹੋ ਸਕਦਾ ਹੈ ਪ੍ਰਾਪਤ ਕਰੋ ਅਤੇ ਪੈਕ ਕੀਤੀ ਵਿਸ਼ੇਸ਼ਤਾ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ। ਇਹ ਧਿਆਨ ਵਿੱਚ ਰੱਖਦੇ ਹੋਏ ਕਿ ਇਹ ਢਾਂਚੇ ਦੁਆਰਾ ਕਬਜ਼ੇ ਵਿੱਚ ਕੀਤੀ ਸਪੇਸ ਦੇ ਅਨੁਕੂਲਨ ਵਿੱਚ ਵੀ ਯੋਗਦਾਨ ਪਾਉਂਦਾ ਹੈ, ਇਹ ਵਿਧੀ ਮੈਨੂੰ ਤਰਜੀਹੀ ਜਾਪਦੀ ਹੈ, ਹਾਲਾਂਕਿ приводит ਡਾਟਾ ਐਕਸੈਸ ਓਪਰੇਸ਼ਨ ਦੀ ਲਾਗਤ ਨੂੰ ਵਧਾਉਣ ਲਈ.

typedef struct __attribute__((packed)) NodeKey {
    uint8_t parentId;
    uint8_t type;
    uint8_t nameLength;
    uint8_t nameBuffer[256];
} NodeKey;

ਰੇਂਜ ਸਵਾਲ

ਰਿਕਾਰਡਾਂ ਦੇ ਸਮੂਹ ਉੱਤੇ ਦੁਹਰਾਉਣ ਲਈ, LMDB ਇੱਕ ਕਰਸਰ ਐਬਸਟਰੈਕਸ਼ਨ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਆਓ ਦੇਖੀਏ ਕਿ ਸਾਡੇ ਲਈ ਪਹਿਲਾਂ ਤੋਂ ਹੀ ਜਾਣੂ ਯੂਜ਼ਰ ਕਲਾਉਡ ਮੈਟਾਡੇਟਾ ਵਾਲੀ ਟੇਬਲ ਦੀ ਉਦਾਹਰਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇਸ ਨਾਲ ਕਿਵੇਂ ਕੰਮ ਕਰਨਾ ਹੈ।

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

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

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

ਖੁਸ਼ਕਿਸਮਤੀ ਨਾਲ, LMDB API ਕਰਸਰ ਨੂੰ ਸ਼ੁਰੂ ਵਿੱਚ ਸਥਿਤੀ ਵਿੱਚ ਰੱਖਣ ਦਾ ਇੱਕ ਕੁਸ਼ਲ ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਅਜਿਹਾ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਅਜਿਹੀ ਕੁੰਜੀ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ, ਜਿਸਦਾ ਮੁੱਲ ਨਿਸ਼ਚਿਤ ਤੌਰ 'ਤੇ ਅੰਤਰਾਲ ਦੇ ਉੱਪਰਲੇ ਸੀਮਾ 'ਤੇ ਸਥਿਤ ਕੁੰਜੀ ਤੋਂ ਘੱਟ ਜਾਂ ਬਰਾਬਰ ਹੋਵੇਗਾ। . ਉਦਾਹਰਨ ਲਈ, ਉਪਰੋਕਤ ਚਿੱਤਰ ਵਿੱਚ ਸੂਚੀ ਦੇ ਸਬੰਧ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਕੁੰਜੀ ਬਣਾ ਸਕਦੇ ਹਾਂ ਜਿਸ ਵਿੱਚ ਖੇਤਰ parentId 2 ਦੇ ਬਰਾਬਰ ਹੋਵੇਗਾ, ਅਤੇ ਬਾਕੀ ਸਾਰੇ ਜ਼ੀਰੋ ਨਾਲ ਭਰੇ ਹੋਏ ਹਨ। ਅਜਿਹੀ ਅੰਸ਼ਕ ਤੌਰ 'ਤੇ ਭਰੀ ਕੁੰਜੀ ਫੰਕਸ਼ਨ ਦੇ ਇੰਪੁੱਟ ਨੂੰ ਫੀਡ ਕੀਤੀ ਜਾਂਦੀ ਹੈ mdb_cursor_get ਕਾਰਵਾਈ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ MDB_SET_RANGE.

NodeKey upperBoundSearchKey = {
    .parentId = 2,
    .type = 0,
    .nameLength = 0
};
MDB_val value, key = serialize(upperBoundSearchKey);
MDB_cursor *cursor;
mdb_cursor_open(..., &cursor);
mdb_cursor_get(cursor, &key, &value, MDB_SET_RANGE);

ਜੇਕਰ ਕੁੰਜੀਆਂ ਦੇ ਸਮੂਹ ਦੀ ਉਪਰਲੀ ਸੀਮਾ ਪਾਈ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਅਸੀਂ ਇਸ ਨੂੰ ਉਦੋਂ ਤੱਕ ਦੁਹਰਾਉਂਦੇ ਹਾਂ ਜਦੋਂ ਤੱਕ ਅਸੀਂ ਕਿਸੇ ਹੋਰ ਨਾਲ ਨਹੀਂ ਮਿਲਦੇ ਜਾਂ ਕੁੰਜੀ ਨੂੰ parentId, ਜਾਂ ਕੁੰਜੀਆਂ ਬਿਲਕੁਲ ਵੀ ਖਤਮ ਨਹੀਂ ਹੋਣਗੀਆਂ

do {
    rc = mdb_cursor_get(cursor, &key, &value, MDB_NEXT);
    // processing...
} while (MDB_NOTFOUND != rc && // check end of table
         IsTargetKey(key));    // check end of keys group

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

4.3 ਟੇਬਲ ਵਿਚਕਾਰ ਮਾਡਲਿੰਗ ਸਬੰਧ

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

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

ਇੰਡੈਕਸ ਟੇਬਲ

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

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

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

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

ਅੱਗੇ, ਅਸੀਂ ਵਿਚਾਰ ਕਰਾਂਗੇ ਕਿ ਇਹਨਾਂ ਕਮੀਆਂ ਨੂੰ ਕਿਵੇਂ ਦੂਰ ਕਰਨਾ ਹੈ.

ਟੇਬਲ ਦੇ ਵਿਚਕਾਰ ਸਬੰਧਾਂ ਦਾ ਸੰਗਠਨ

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

ਟੇਬਲ ਦੇ ਵਿਚਕਾਰ ਸਬੰਧਾਂ ਨੂੰ ਸੰਗਠਿਤ ਕਰਨ ਲਈ ਇੱਕ ਹੋਰ ਪੈਟਰਨ ਹੈ "ਬੇਲੋੜੀ ਕੁੰਜੀ". ਇਸਦਾ ਸਾਰ ਕੁੰਜੀ ਵਿੱਚ ਵਾਧੂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਜੋੜਨਾ ਹੈ, ਜੋ ਕਿ ਛਾਂਟਣ ਲਈ ਨਹੀਂ, ਪਰ ਸੰਬੰਧਿਤ ਕੁੰਜੀ ਨੂੰ ਮੁੜ ਬਣਾਉਣ ਲਈ ਲੋੜੀਂਦੇ ਹਨ। Mail.ru ਕਲਾਉਡ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਇਸਦੀ ਵਰਤੋਂ ਦੀਆਂ ਅਸਲ ਉਦਾਹਰਣਾਂ ਹਨ, ਹਾਲਾਂਕਿ, ਇਸ ਵਿੱਚ ਡੂੰਘੀ ਗੋਤਾਖੋਰੀ ਤੋਂ ਬਚਣ ਲਈ ਖਾਸ iOS ਫਰੇਮਵਰਕ ਦੇ ਸੰਦਰਭ ਵਿੱਚ, ਮੈਂ ਇੱਕ ਫਰਜ਼ੀ, ਪਰ ਇੱਕ ਹੋਰ ਸਮਝਣ ਯੋਗ ਉਦਾਹਰਣ ਦੇਵਾਂਗਾ।

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

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

ਸਿੱਟਾ

ਅਸੀਂ LMDB ਲਾਗੂ ਕਰਨ ਦੇ ਨਤੀਜਿਆਂ ਦਾ ਸਕਾਰਾਤਮਕ ਮੁਲਾਂਕਣ ਕਰਦੇ ਹਾਂ। ਇਸ ਤੋਂ ਬਾਅਦ, ਐਪਲੀਕੇਸ਼ਨ ਫ੍ਰੀਜ਼ ਦੀ ਗਿਣਤੀ 30% ਘਟ ਗਈ.

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

ਸਰੋਤ: www.habr.com

ਆਈਓਐਸ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਮੁੱਖ-ਮੁੱਲ ਡੇਟਾਬੇਸ LMDB ਦੀ ਚਮਕ ਅਤੇ ਗਰੀਬੀ