ਇਸ ਲੇਖ ਦਾ ਉਦੇਸ਼ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਉਦਾਹਰਣ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਹੈ ਸਕੀਮਾ-ਕੀਪਰ ਟੂਲ ਦਿਖਾਓ ਜੋ PostgreSQL DBMS ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ PHP ਪ੍ਰੋਜੈਕਟਾਂ ਦੇ ਅੰਦਰ ਡਾਟਾਬੇਸ ਵਿਕਸਿਤ ਕਰਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਮਹੱਤਵਪੂਰਨ ਤੌਰ 'ਤੇ ਸਰਲ ਬਣਾ ਸਕਦੇ ਹਨ।

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

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

ਹੇਠਾਂ ਦਿੱਤੇ ਸਵਾਲਾਂ 'ਤੇ ਵਿਚਾਰ ਕੀਤਾ ਜਾਵੇਗਾ:

1. ਇੱਕ ਡੇਟਾਬੇਸ ਢਾਂਚੇ ਦੇ ਡੰਪ ਨੂੰ ਇੱਕ ਵਰਜਨ ਕੰਟਰੋਲ ਸਿਸਟਮ ਵਿੱਚ ਕਿਸ ਰੂਪ ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ (ਇਸ ਤੋਂ ਬਾਅਦ VCS ਵਜੋਂ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ)
2. ਇੱਕ ਡੰਪ ਨੂੰ ਬਚਾਉਣ ਤੋਂ ਬਾਅਦ ਡੇਟਾਬੇਸ ਢਾਂਚੇ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਨੂੰ ਕਿਵੇਂ ਟਰੈਕ ਕਰਨਾ ਹੈ
3. ਡੇਟਾਬੇਸ ਢਾਂਚੇ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਨੂੰ ਬਿਨਾਂ ਕਿਸੇ ਵਿਵਾਦ ਅਤੇ ਵਿਸ਼ਾਲ ਮਾਈਗ੍ਰੇਸ਼ਨ ਫਾਈਲਾਂ ਦੇ ਦੂਜੇ ਵਾਤਾਵਰਣ ਵਿੱਚ ਕਿਵੇਂ ਟ੍ਰਾਂਸਫਰ ਕਰਨਾ ਹੈ
4. ਕਈ ਡਿਵੈਲਪਰਾਂ ਦੁਆਰਾ ਇੱਕ ਪ੍ਰੋਜੈਕਟ 'ਤੇ ਸਮਾਨਾਂਤਰ ਕੰਮ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਕਿਵੇਂ ਸੰਗਠਿਤ ਕਰਨਾ ਹੈ
5. ਇੱਕ ਉਤਪਾਦਨ ਵਾਤਾਵਰਣ ਵਿੱਚ ਡੇਟਾਬੇਸ ਢਾਂਚੇ ਵਿੱਚ ਹੋਰ ਤਬਦੀਲੀਆਂ ਨੂੰ ਸੁਰੱਖਿਅਤ ਢੰਗ ਨਾਲ ਕਿਵੇਂ ਲਾਗੂ ਕਰਨਾ ਹੈ
   

   ਸਕੀਮਾਕੀਪਰ ਭਾਸ਼ਾ ਵਿੱਚ ਲਿਖੀਆਂ ਸਟੋਰ ਕੀਤੀਆਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ PL/pgSQL. ਦੂਜੀਆਂ ਭਾਸ਼ਾਵਾਂ ਨਾਲ ਟੈਸਟਿੰਗ ਨਹੀਂ ਕੀਤੀ ਗਈ ਹੈ, ਇਸਲਈ ਵਰਤੋਂ ਓਨੀ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਨਹੀਂ ਹੋ ਸਕਦੀ ਜਾਂ ਸੰਭਵ ਨਹੀਂ ਹੋ ਸਕਦੀ।

VCS ਵਿੱਚ ਇੱਕ ਡੇਟਾਬੇਸ ਢਾਂਚਾ ਡੰਪ ਨੂੰ ਕਿਵੇਂ ਸਟੋਰ ਕਰਨਾ ਹੈ

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

ਆਉ ਕਈ ਉਦਾਹਰਣਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਡੇਟਾਬੇਸ ਤੋਂ ਆਬਜੈਕਟ ਨੂੰ ਫਾਈਲਾਂ ਵਿੱਚ ਬਦਲਦੇ ਹੋਏ ਵੇਖੀਏ:

ਵਸਤੂ ਦੀ ਕਿਸਮ
ਸਕੀਮ
ਟਾਈਟਲ
ਫਾਈਲ ਲਈ ਸੰਬੰਧਿਤ ਮਾਰਗ

ਸਾਰਣੀ ਵਿੱਚ
ਜਨਤਕ
ਖਾਤੇ
./public/tables/accounts.txt

ਸਟੋਰ ਕੀਤੀ ਪ੍ਰਕਿਰਿਆ
ਜਨਤਕ
auth(ਹੈਸ਼ ਬਿਗਿੰਟ)
./public/functions/auth(int8).sql

ਜਾਣ ਪਛਾਣ
ਬੁਕਿੰਗ
ਦਰਾਂ
./booking/views/tariffs.txt

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

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

ਐਕਸ਼ਟੇਸ਼ਨ .sql ਸਟੋਰ ਕੀਤੇ ਪ੍ਰਕਿਰਿਆ ਸਰੋਤ ਕੋਡ ਵਾਲੀਆਂ ਫਾਈਲਾਂ ਲਈ, ਇਹ ਇਸ ਲਈ ਚੁਣਿਆ ਗਿਆ ਸੀ ਤਾਂ ਕਿ IDE ਆਪਣੇ ਆਪ ਹੀ ਡਾਟਾਬੇਸ ਨਾਲ ਇੰਟਰੈਕਟ ਕਰਨ ਲਈ ਟੂਲ ਪ੍ਰਦਾਨ ਕਰੇ ਜਦੋਂ ਫਾਈਲ ਖੋਲ੍ਹੀ ਜਾਂਦੀ ਹੈ।

ਇੱਕ ਡੰਪ ਨੂੰ ਬਚਾਉਣ ਤੋਂ ਬਾਅਦ ਡੇਟਾਬੇਸ ਢਾਂਚੇ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਨੂੰ ਕਿਵੇਂ ਟਰੈਕ ਕਰਨਾ ਹੈ

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

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

ਡੇਟਾਬੇਸ ਢਾਂਚੇ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਨੂੰ ਬਿਨਾਂ ਕਿਸੇ ਵਿਵਾਦ ਅਤੇ ਵਿਸ਼ਾਲ ਮਾਈਗ੍ਰੇਸ਼ਨ ਫਾਈਲਾਂ ਦੇ ਦੂਜੇ ਵਾਤਾਵਰਣ ਵਿੱਚ ਕਿਵੇਂ ਟ੍ਰਾਂਸਫਰ ਕਰਨਾ ਹੈ

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

ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਸਕੀਮਾ ਵਿੱਚ ਇੱਕ ਨਵੀਂ ਸਟੋਰ ਕੀਤੀ ਵਿਧੀ ਬਣਾਉਣ ਲਈ public ਸਿਰਫ਼ ਐਕਸਟੈਂਸ਼ਨ ਨਾਲ ਇੱਕ ਨਵੀਂ ਫਾਈਲ ਬਣਾਓ .sql ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ public/functions, ਇਸ ਵਿੱਚ ਸਟੋਰ ਕੀਤੀ ਪ੍ਰਕਿਰਿਆ ਦਾ ਸਰੋਤ ਕੋਡ ਰੱਖੋ, ਬਲਾਕ ਸਮੇਤ CREATE OR REPLACE FUNCTION, ਫਿਰ ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰੋ deployDump. ਇੱਕ ਸਟੋਰ ਕੀਤੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਸੋਧਣਾ ਅਤੇ ਮਿਟਾਉਣਾ ਉਸੇ ਤਰ੍ਹਾਂ ਹੁੰਦਾ ਹੈ. ਇਸ ਤਰ੍ਹਾਂ, ਕੋਡ ਇੱਕੋ ਸਮੇਂ VCS ਅਤੇ ਡੇਟਾਬੇਸ ਦੋਵਾਂ ਵਿੱਚ ਜਾਂਦਾ ਹੈ।

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

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

deployDump ਤੁਹਾਨੂੰ ਫੰਕਸ਼ਨ ਦੇ ਪੈਰਾਮੀਟਰਾਂ ਨੂੰ ਬਦਲਣ ਜਾਂ ਵਾਧੂ ਕਾਰਵਾਈਆਂ ਤੋਂ ਬਿਨਾਂ ਕਿਸਮ ਵਾਪਸ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਜਦੋਂ ਕਿ ਕਲਾਸੀਕਲ ਪਹੁੰਚ ਨਾਲ ਤੁਹਾਨੂੰ
ਪਹਿਲਾਂ ਚਲਾਓ DROP FUNCTION, ਅਤੇ ਕੇਵਲ ਤਦ CREATE OR REPLACE FUNCTION.

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

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

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

ਮਾਈਗ੍ਰੇਸ਼ਨ ਦੇ ਨਾਲ ਕੰਮ ਕਰਨ ਦਾ ਵਰਣਨ ਹੇਠਾਂ ਦਿੱਤੇ ਭਾਗਾਂ ਵਿੱਚ ਵਧੇਰੇ ਵਿਸਥਾਰ ਵਿੱਚ ਕੀਤਾ ਜਾਵੇਗਾ।

ਕਈ ਡਿਵੈਲਪਰਾਂ ਦੁਆਰਾ ਇੱਕ ਪ੍ਰੋਜੈਕਟ 'ਤੇ ਸਮਾਨਾਂਤਰ ਕੰਮ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਕਿਵੇਂ ਸੰਗਠਿਤ ਕਰਨਾ ਹੈ

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

1. ਇੱਕ ਬੁਨਿਆਦੀ ਢਾਂਚੇ ਵਾਲੀ ਇੱਕ ਫਾਈਲ ਆਯਾਤ ਕਰੋ ਜਿਸਨੂੰ ਕਿਹਾ ਜਾਵੇਗਾ ਜਿਵੇਂ ਕਿ base.sql
2. ਮਾਈਗ੍ਰੇਸ਼ਨ ਲਾਗੂ ਕਰਨਾ
3. ਚੁਣੌਤੀ deployDump

base.sql ਉਹ ਸ਼ੁਰੂਆਤੀ ਬਿੰਦੂ ਹੈ ਜਿਸ ਦੇ ਸਿਖਰ 'ਤੇ ਮਾਈਗ੍ਰੇਸ਼ਨ ਲਾਗੂ ਅਤੇ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ deployDump, ਇਹ ਹੈ base.sql + миграции + deployDump = актуальная структура БД. ਤੁਸੀਂ ਉਪਯੋਗਤਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਜਿਹੀ ਫਾਈਲ ਬਣਾ ਸਕਦੇ ਹੋ pg_dump. ਵਰਤਿਆ base.sql ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਜਦੋਂ ਸਕਰੈਚ ਤੋਂ ਡੇਟਾਬੇਸ ਨੂੰ ਸ਼ੁਰੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਆਉ ਪੂਰੇ ਡੇਟਾਬੇਸ ਸ਼ੁਰੂਆਤੀਕਰਣ ਲਈ ਸਕ੍ਰਿਪਟ ਨੂੰ ਕਾਲ ਕਰੀਏ refresh.sh. ਵਰਕਫਲੋ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇ ਸਕਦਾ ਹੈ:

1. ਡਿਵੈਲਪਰ ਆਪਣੇ ਵਾਤਾਵਰਣ ਵਿੱਚ ਲਾਂਚ ਕਰਦਾ ਹੈ refresh.sh ਅਤੇ ਮੌਜੂਦਾ ਡਾਟਾਬੇਸ ਢਾਂਚਾ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ
2. ਡਿਵੈਲਪਰ ਨਵੇਂ ਕਾਰਜਸ਼ੀਲਤਾ (ALTER TABLE ... ADD COLUMN ਆਦਿ)
3. ਕੰਮ ਨੂੰ ਪੂਰਾ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਡਿਵੈਲਪਰ ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ saveDumpVCS ਵਿੱਚ ਡੇਟਾਬੇਸ ਵਿੱਚ ਕੀਤੀਆਂ ਤਬਦੀਲੀਆਂ ਕਰਨ ਲਈ
4. ਵਿਕਾਸਕਾਰ ਮੁੜ-ਲਾਂਚ refresh.shਫਿਰ verifyDumpਜੋ ਹੁਣ ਮਾਈਗ੍ਰੇਸ਼ਨ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਨ ਲਈ ਤਬਦੀਲੀਆਂ ਦੀ ਸੂਚੀ ਦਿਖਾਉਂਦਾ ਹੈ
5. ਡਿਵੈਲਪਰ ਸਾਰੇ ਢਾਂਚੇ ਦੇ ਬਦਲਾਅ ਨੂੰ ਮਾਈਗ੍ਰੇਸ਼ਨ ਫਾਈਲ ਵਿੱਚ ਟ੍ਰਾਂਸਫਰ ਕਰਦਾ ਹੈ, ਦੁਬਾਰਾ ਚੱਲਦਾ ਹੈ refresh.sh и verifyDump, ਅਤੇ, ਜੇਕਰ ਮਾਈਗ੍ਰੇਸ਼ਨ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਕੰਪਾਇਲ ਕੀਤਾ ਗਿਆ ਹੈ, verifyDump ਸਥਾਨਕ ਡਾਟਾਬੇਸ ਅਤੇ ਸੁਰੱਖਿਅਤ ਕੀਤੇ ਡੰਪ ਵਿੱਚ ਕੋਈ ਅੰਤਰ ਨਹੀਂ ਦਿਖਾਏਗਾ

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

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

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

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

ਲੈ ਡੀਡੀਐਲ PostgreSQL ਵਿੱਚ ਹੈ ਲੈਣ-ਦੇਣ, ਹੇਠਾਂ ਦਿੱਤੇ ਡਿਪਲਾਇਮੈਂਟ ਆਰਡਰ ਦੀ ਪਾਲਣਾ ਕਰਨ ਦੀ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਜੋ, ਇੱਕ ਅਚਾਨਕ ਗਲਤੀ ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਤੁਸੀਂ "ਦਰਦ ਰਹਿਤ" ਅਮਲ ਕਰ ਸਕੋ। ROLLBACK:

1. ਲੈਣ-ਦੇਣ ਸ਼ੁਰੂ ਕਰੋ
2. ਇੱਕ ਲੈਣ-ਦੇਣ ਵਿੱਚ ਸਾਰੇ ਮਾਈਗ੍ਰੇਸ਼ਨ ਕਰੋ
3. ਉਸੇ ਲੈਣ-ਦੇਣ ਵਿੱਚ, ਚਲਾਓ deployDump
4. ਲੈਣ-ਦੇਣ ਨੂੰ ਪੂਰਾ ਕੀਤੇ ਬਿਨਾਂ, ਚਲਾਓ verifyDump. ਜੇ ਕੋਈ ਗਲਤੀਆਂ ਨਹੀਂ ਹਨ, ਤਾਂ ਚਲਾਓ COMMIT. ਜੇ ਕੋਈ ਗਲਤੀਆਂ ਹਨ, ਤਾਂ ਚਲਾਓ ROLLBACK

ਇਹਨਾਂ ਕਦਮਾਂ ਨੂੰ ਜ਼ੀਰੋ-ਡਾਊਨਟਾਈਮ ਸਮੇਤ, ਐਪਲੀਕੇਸ਼ਨ ਡਿਪਲਾਇਮੈਂਟ ਲਈ ਮੌਜੂਦਾ ਪਹੁੰਚਾਂ ਵਿੱਚ ਆਸਾਨੀ ਨਾਲ ਜੋੜਿਆ ਜਾ ਸਕਦਾ ਹੈ।

ਸਿੱਟਾ

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

ਸਰੋਤ: www.habr.com