ഈ ലേഖനത്തിന്റെ ഉദ്ദേശ്യം ഒരു ലൈബ്രറിയുടെ ഉദാഹരണം ഉപയോഗിക്കുക എന്നതാണ് സ്കീമ-കീപ്പർ PostgreSQL DBMS ഉപയോഗിച്ച് PHP പ്രോജക്റ്റുകളിൽ ഡാറ്റാബേസുകൾ വികസിപ്പിക്കുന്ന പ്രക്രിയയെ ഗണ്യമായി ലളിതമാക്കാൻ കഴിയുന്ന ഉപകരണങ്ങൾ കാണിക്കുക.

ഈ ലേഖനത്തിൽ നിന്നുള്ള വിവരങ്ങൾ, ഒന്നാമതായി, PostgreSQL കഴിവുകൾ പരമാവധി പ്രയോജനപ്പെടുത്താൻ ആഗ്രഹിക്കുന്ന ഡെവലപ്പർമാർക്ക് ഉപയോഗപ്രദമാകും, എന്നാൽ ഡാറ്റാബേസിൽ സ്ഥാപിച്ചിട്ടുള്ള ബിസിനസ്സ് ലോജിക് നിലനിർത്തുന്നതിൽ പ്രശ്നങ്ങൾ നേരിടുന്നു.

ഒരു ഡാറ്റാബേസിൽ ബിസിനസ്സ് ലോജിക് സൂക്ഷിക്കുന്നതിന്റെ ഗുണങ്ങളും ദോഷങ്ങളും ഈ ലേഖനം വിവരിക്കുന്നില്ല. തിരഞ്ഞെടുക്കൽ ഇതിനകം വായനക്കാരൻ നടത്തിയിട്ടുണ്ടെന്ന് അനുമാനിക്കുന്നു.

ഇനിപ്പറയുന്ന ചോദ്യങ്ങൾ പരിഗണിക്കും:

1. ഏത് രൂപത്തിലാണ് ഒരു ഡാറ്റാബേസ് ഘടന ഡംപ് ഒരു പതിപ്പ് കൺട്രോൾ സിസ്റ്റത്തിൽ സൂക്ഷിക്കേണ്ടത് (ഇനിമുതൽ VCS എന്ന് വിളിക്കുന്നു)
2. ഒരു ഡംപ് സംരക്ഷിച്ചതിന് ശേഷം ഡാറ്റാബേസ് ഘടനയിലെ മാറ്റങ്ങൾ എങ്ങനെ ട്രാക്ക് ചെയ്യാം
3. വൈരുദ്ധ്യങ്ങളും ഭീമൻ മൈഗ്രേഷൻ ഫയലുകളും ഇല്ലാതെ ഡാറ്റാബേസ് ഘടനയിലെ മാറ്റങ്ങൾ മറ്റ് പരിതസ്ഥിതികളിലേക്ക് എങ്ങനെ കൈമാറാം
4. നിരവധി ഡവലപ്പർമാർ ഒരു പ്രോജക്റ്റിൽ സമാന്തര ജോലിയുടെ പ്രക്രിയ എങ്ങനെ സംഘടിപ്പിക്കാം
5. ഒരു പ്രൊഡക്ഷൻ എൻവയോൺമെന്റിലേക്ക് ഡാറ്റാബേസ് ഘടനയിൽ കൂടുതൽ മാറ്റങ്ങൾ എങ്ങനെ സുരക്ഷിതമായി വിന്യസിക്കാം
   

   സ്കീമകീപ്പർ ഭാഷയിൽ എഴുതിയ സംഭരിച്ച നടപടിക്രമങ്ങളുമായി പ്രവർത്തിക്കാൻ രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു PL/pgSQL. മറ്റ് ഭാഷകളുമായുള്ള പരിശോധന നടത്തിയിട്ടില്ല, അതിനാൽ ഉപയോഗം അത്ര ഫലപ്രദമാകണമെന്നില്ല അല്ലെങ്കിൽ സാധ്യമായേക്കില്ല.

VCS-ൽ ഒരു ഡാറ്റാബേസ് ഘടന ഡംപ് എങ്ങനെ സംഭരിക്കാം

ലൈബ്രറി സ്കീമ-കീപ്പർ ഒരു ഫംഗ്ഷൻ നൽകുന്നു saveDump, ഇത് ഡാറ്റാബേസിൽ നിന്ന് എല്ലാ ഒബ്ജക്റ്റുകളുടെയും ഘടനയെ പ്രത്യേക ടെക്സ്റ്റ് ഫയലുകളായി സംരക്ഷിക്കുന്നു. ഔട്ട്‌പുട്ട് എന്നത് ഡാറ്റാബേസ് ഘടന ഉൾക്കൊള്ളുന്ന ഒരു ഡയറക്ടറിയാണ്, വിസിഎസിലേക്ക് എളുപ്പത്തിൽ ചേർക്കാൻ കഴിയുന്ന ഗ്രൂപ്പുചെയ്ത ഫയലുകളായി തിരിച്ചിരിക്കുന്നു.

നിരവധി ഉദാഹരണങ്ങൾ ഉപയോഗിച്ച് ഒരു ഡാറ്റാബേസിൽ നിന്ന് ഒബ്ജക്റ്റുകളെ ഫയലുകളാക്കി മാറ്റുന്നത് നോക്കാം:

ഒബ്ജക്റ്റ് തരം
പദ്ധതി
ശീർഷകം
ഫയലിലേക്കുള്ള ആപേക്ഷിക പാത

പട്ടിക
പൊതു
അക്കൗണ്ടുകൾ
./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. സംഭരിച്ച നടപടിക്രമം പരിഷ്കരിക്കുന്നതും ഇല്ലാതാക്കുന്നതും അതേ രീതിയിൽ തന്നെ സംഭവിക്കുന്നു. അങ്ങനെ, കോഡ് വിസിഎസിലേക്കും ഡാറ്റാബേസിലേക്കും ഒരേ സമയം പോകുന്നു.

സംഭരിച്ച ഏതെങ്കിലും നടപടിക്രമത്തിന്റെ സോഴ്സ് കോഡിൽ ഒരു പിശക് അല്ലെങ്കിൽ ഫയലിന്റെ പേരുകളും സംഭരിച്ച നടപടിക്രമവും തമ്മിലുള്ള പൊരുത്തക്കേട് ദൃശ്യമാകുകയാണെങ്കിൽ, തുടർന്ന് deployDump പരാജയപ്പെടും, പിശക് വാചകം പ്രദർശിപ്പിക്കുന്നു. ഉപയോഗിക്കുമ്പോൾ ഡമ്പും നിലവിലെ ഡാറ്റാബേസും തമ്മിലുള്ള സംഭരിച്ച നടപടിക്രമങ്ങളുടെ പൊരുത്തക്കേട് അസാധ്യമാണ് deployDump.

ഒരു പുതിയ സംഭരിച്ച നടപടിക്രമം സൃഷ്ടിക്കുമ്പോൾ, ശരിയായ ഫയലിന്റെ പേര് സ്വമേധയാ നൽകേണ്ടതില്ല. ഫയലിന് എക്സ്റ്റൻഷൻ ഉണ്ടായാൽ മതി .sql. കോളിന് ശേഷം deployDump പിശക് വാചകത്തിൽ ശരിയായ പേര് അടങ്ങിയിരിക്കും, അത് ഫയലിന്റെ പേരുമാറ്റാൻ ഉപയോഗിക്കാം.

deployDump ഒരു ഫംഗ്‌ഷന്റെ പാരാമീറ്ററുകൾ മാറ്റാൻ നിങ്ങളെ അനുവദിക്കുന്നു അല്ലെങ്കിൽ അധിക പ്രവർത്തനങ്ങളില്ലാതെ റിട്ടേൺ തരം, ക്ലാസിക്കൽ സമീപനത്തിൽ നിങ്ങൾ ചെയ്യേണ്ടത്
ആദ്യം നടപ്പിലാക്കുക DROP FUNCTION, പിന്നെ മാത്രം CREATE OR REPLACE FUNCTION.

നിർഭാഗ്യവശാൽ, ചില സാഹചര്യങ്ങളുണ്ട് deployDump മാറ്റങ്ങൾ സ്വയമേവ പ്രയോഗിക്കാൻ കഴിയുന്നില്ല. ഉദാഹരണത്തിന്, കുറഞ്ഞത് ഒരു ട്രിഗർ ഉപയോഗിക്കുന്ന ഒരു ട്രിഗർ ഫംഗ്‌ഷൻ നീക്കം ചെയ്‌താൽ. മൈഗ്രേഷൻ ഫയലുകൾ ഉപയോഗിച്ച് ഇത്തരം സാഹചര്യങ്ങൾ സ്വമേധയാ പരിഹരിക്കുന്നു.

സംഭരിച്ച നടപടിക്രമങ്ങളിലേക്ക് മാറ്റങ്ങൾ മൈഗ്രേറ്റ് ചെയ്യുന്നതിന് നിങ്ങൾ ഉത്തരവാദിയാണെങ്കിൽ സ്കീമ-കീപ്പർ, തുടർന്ന് ഘടനയിലെ മറ്റ് മാറ്റങ്ങൾ കൈമാറാൻ മൈഗ്രേഷൻ ഫയലുകൾ ഉപയോഗിക്കണം. ഉദാഹരണത്തിന്, മൈഗ്രേഷനുമായി പ്രവർത്തിക്കുന്നതിനുള്ള ഒരു നല്ല ലൈബ്രറിയാണ് സിദ്ധാന്തം/കുടിയേറ്റങ്ങൾ.

സമാരംഭിക്കുന്നതിന് മുമ്പ് മൈഗ്രേഷനുകൾ പ്രയോഗിക്കണം deployDump. ഘടനയിൽ എല്ലാ മാറ്റങ്ങളും വരുത്താനും പ്രശ്നകരമായ സാഹചര്യങ്ങൾ പരിഹരിക്കാനും ഇത് നിങ്ങളെ അനുവദിക്കുന്നു, അങ്ങനെ സംഭരിച്ച നടപടിക്രമങ്ങളിലെ മാറ്റങ്ങൾ പിന്നീട് പ്രശ്നങ്ങളില്ലാതെ കൈമാറ്റം ചെയ്യപ്പെടും.

മൈഗ്രേഷനുമായി പ്രവർത്തിക്കുന്നത് ഇനിപ്പറയുന്ന വിഭാഗങ്ങളിൽ കൂടുതൽ വിശദമായി വിവരിക്കും.

നിരവധി ഡവലപ്പർമാർ ഒരു പ്രോജക്റ്റിൽ സമാന്തര ജോലിയുടെ പ്രക്രിയ എങ്ങനെ സംഘടിപ്പിക്കാം

ഡാറ്റാബേസിന്റെ സമ്പൂർണ്ണ സമാരംഭത്തിനായി ഒരു സ്ക്രിപ്റ്റ് സൃഷ്ടിക്കേണ്ടത് ആവശ്യമാണ്, അത് ഡെവലപ്പർ തന്റെ വർക്ക് മെഷീനിൽ സമാരംഭിക്കും, പ്രാദേശിക ഡാറ്റാബേസിന്റെ ഘടന വിസിഎസിൽ സംരക്ഷിച്ചിരിക്കുന്ന ഡമ്പിന് അനുസൃതമായി കൊണ്ടുവരും. ലോക്കൽ ഡാറ്റാബേസിന്റെ സമാരംഭം 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-ലെ ഓരോ ബ്രാഞ്ചിലും ഡംപിന്റെ സ്വന്തം പതിപ്പ് അടങ്ങിയിരിക്കും, ബ്രാഞ്ചുകൾ ലയിപ്പിക്കുമ്പോൾ, ഡംപുകൾ ലയിപ്പിക്കും. മിക്ക കേസുകളിലും, ഒരു ലയനത്തിനുശേഷം അധിക നടപടികളൊന്നും എടുക്കേണ്ടതില്ല, എന്നാൽ വ്യത്യസ്ത ശാഖകളിൽ മാറ്റങ്ങൾ വരുത്തിയാൽ, ഉദാഹരണത്തിന്, ഒരേ പട്ടികയിൽ, ഒരു വൈരുദ്ധ്യം ഉണ്ടാകാം.

ഒരു ഉദാഹരണം ഉപയോഗിച്ച് ഒരു സംഘട്ടന സാഹചര്യം പരിഗണിക്കാം: ഒരു ശാഖയുണ്ട് വികസിപ്പിക്കുക, അതിൽ നിന്ന് രണ്ട് ശാഖകൾ ശാഖകൾ: സവിശേഷത 1 и സവിശേഷത 2, ഇവയുമായി വൈരുദ്ധ്യങ്ങളൊന്നുമില്ല വികസിപ്പിക്കുക, എന്നാൽ പരസ്പരം കലഹങ്ങൾ ഉണ്ട്. രണ്ട് ശാഖകളും ലയിപ്പിക്കുക എന്നതാണ് ചുമതല വികസിപ്പിക്കുക. ഈ സാഹചര്യത്തിൽ, ആദ്യം ശാഖകളിലൊന്ന് ലയിപ്പിക്കാൻ ശുപാർശ ചെയ്യുന്നു വികസിപ്പിക്കുകതുടർന്ന് ലയിപ്പിക്കുക വികസിപ്പിക്കുക ശേഷിക്കുന്ന ശാഖയിലേക്ക്, ശേഷിക്കുന്ന ശാഖയിലെ വൈരുദ്ധ്യങ്ങൾ പരിഹരിക്കുക, തുടർന്ന് അവസാനത്തെ ശാഖയിൽ ലയിപ്പിക്കുക വികസിപ്പിക്കുക. വൈരുദ്ധ്യ പരിഹാര ഘട്ടത്തിൽ, അവസാന ബ്രാഞ്ചിലെ മൈഗ്രേഷൻ ഫയൽ നിങ്ങൾ പരിഹരിക്കേണ്ടി വന്നേക്കാം, അതുവഴി അത് ലയനത്തിന്റെ ഫലങ്ങൾ ഉൾപ്പെടുന്ന അന്തിമ ഡമ്പുമായി പൊരുത്തപ്പെടുന്നു.

ഒരു പ്രൊഡക്ഷൻ എൻവയോൺമെന്റിലേക്ക് ഡാറ്റാബേസ് ഘടനയിൽ കൂടുതൽ മാറ്റങ്ങൾ എങ്ങനെ സുരക്ഷിതമായി വിന്യസിക്കാം

വിസിഎസിലെ നിലവിലെ ഡാറ്റാബേസ് ഘടനയുടെ ഒരു ഡംപ് സാന്നിധ്യത്തിന് നന്ദി, ആവശ്യമായ ഘടനയുമായി കൃത്യമായി പാലിക്കുന്നതിനായി പ്രൊഡക്ഷൻ ഡാറ്റാബേസ് പരിശോധിക്കുന്നത് സാധ്യമാണ്. ഡവലപ്പർമാർ ഉദ്ദേശിച്ച എല്ലാ മാറ്റങ്ങളും ഉൽപ്പാദന അടിത്തറയിലേക്ക് വിജയകരമായി കൈമാറ്റം ചെയ്യപ്പെട്ടതായി ഇത് ഉറപ്പാക്കുന്നു.

പിന്നീട് ഡി.ഡി.എൽ. PostgreSQL-ൽ ആണ് ഇടപാട്, ഇനിപ്പറയുന്ന വിന്യാസ ക്രമം പാലിക്കാൻ ശുപാർശ ചെയ്യുന്നു, അതിനാൽ, ഒരു അപ്രതീക്ഷിത പിശക് സംഭവിച്ചാൽ, നിങ്ങൾക്ക് "വേദനകൂടാതെ" നടപ്പിലാക്കാൻ കഴിയും ROLLBACK:

1. ഇടപാട് ആരംഭിക്കുക
2. ഒരു ഇടപാടിൽ എല്ലാ മൈഗ്രേഷനുകളും നടത്തുക
3. അതേ ഇടപാടിൽ, എക്സിക്യൂട്ട് ചെയ്യുക deployDump
4. ഇടപാട് പൂർത്തിയാക്കാതെ, എക്സിക്യൂട്ട് ചെയ്യുക verifyDump. പിശകുകളൊന്നുമില്ലെങ്കിൽ, പ്രവർത്തിപ്പിക്കുക COMMIT. പിശകുകൾ ഉണ്ടെങ്കിൽ, പ്രവർത്തിപ്പിക്കുക ROLLBACK

സീറോ-ഡൗൺടൈം ഉൾപ്പെടെ, ആപ്ലിക്കേഷൻ വിന്യാസത്തിനുള്ള നിലവിലുള്ള സമീപനങ്ങളിലേക്ക് ഈ ഘട്ടങ്ങൾ എളുപ്പത്തിൽ സംയോജിപ്പിക്കാൻ കഴിയും.

തീരുമാനം

മുകളിൽ വിവരിച്ച രീതികൾക്ക് നന്ദി, "PHP + PostgreSQL" പ്രോജക്റ്റുകളിൽ നിന്ന് പരമാവധി പ്രകടനം പുറത്തെടുക്കാൻ സാധിക്കും, അതേസമയം പ്രധാന ആപ്ലിക്കേഷൻ കോഡിലെ എല്ലാ ബിസിനസ്സ് ലോജിക്കും നടപ്പിലാക്കുന്നതുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ താരതമ്യേന ചെറിയ വികസന സൗകര്യം ത്യജിക്കാൻ കഴിയും. കൂടാതെ, ഡാറ്റ പ്രോസസ്സിംഗ് ഇൻ PL/pgSQL പലപ്പോഴും കൂടുതൽ സുതാര്യമായി കാണപ്പെടുന്നു കൂടാതെ PHP-യിൽ എഴുതിയ അതേ പ്രവർത്തനക്ഷമതയേക്കാൾ കുറഞ്ഞ കോഡ് ആവശ്യമാണ്.

അവലംബം: www.habr.com