ಈ ಲೇಖನದ ಉದ್ದೇಶವು ಗ್ರಂಥಾಲಯದ ಉದಾಹರಣೆಯನ್ನು ಬಳಸುವುದು ಸ್ಕೀಮಾ-ಕೀಪರ್ PostgreSQL DBMS ಅನ್ನು ಬಳಸಿಕೊಂಡು PHP ಯೋಜನೆಗಳಲ್ಲಿ ಡೇಟಾಬೇಸ್‌ಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಸರಳಗೊಳಿಸುವ ಪರಿಕರಗಳನ್ನು ತೋರಿಸಿ.

ಈ ಲೇಖನದ ಮಾಹಿತಿಯು ಮೊದಲನೆಯದಾಗಿ, PostgreSQL ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಹೆಚ್ಚು ಮಾಡಲು ಬಯಸುವ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಉಪಯುಕ್ತವಾಗಿರುತ್ತದೆ, ಆದರೆ ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ಇರಿಸಲಾದ ವ್ಯವಹಾರ ತರ್ಕವನ್ನು ನಿರ್ವಹಿಸುವಲ್ಲಿ ಸಮಸ್ಯೆಗಳನ್ನು ಎದುರಿಸುತ್ತಿದೆ.

ಈ ಲೇಖನವು ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿ ವ್ಯಾಪಾರ ತರ್ಕವನ್ನು ಸಂಗ್ರಹಿಸುವ ಅನುಕೂಲಗಳು ಅಥವಾ ಅನಾನುಕೂಲಗಳನ್ನು ವಿವರಿಸುವುದಿಲ್ಲ. ಓದುಗರಿಂದ ಆಯ್ಕೆಯನ್ನು ಈಗಾಗಲೇ ಮಾಡಲಾಗಿದೆ ಎಂದು ಭಾವಿಸಲಾಗಿದೆ.

ಕೆಳಗಿನ ಪ್ರಶ್ನೆಗಳನ್ನು ಪರಿಗಣಿಸಲಾಗುವುದು:

1. ಆವೃತ್ತಿ ನಿಯಂತ್ರಣ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಡೇಟಾಬೇಸ್ ರಚನೆ ಡಂಪ್ ಅನ್ನು ಯಾವ ರೂಪದಲ್ಲಿ ಸಂಗ್ರಹಿಸಬೇಕು (ಇನ್ನು ಮುಂದೆ VCS ಎಂದು ಉಲ್ಲೇಖಿಸಲಾಗುತ್ತದೆ)
2. ಡಂಪ್ ಅನ್ನು ಉಳಿಸಿದ ನಂತರ ಡೇಟಾಬೇಸ್ ರಚನೆಯಲ್ಲಿ ಬದಲಾವಣೆಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುವುದು ಹೇಗೆ
3. ಸಂಘರ್ಷಗಳು ಮತ್ತು ದೈತ್ಯ ವಲಸೆ ಫೈಲ್‌ಗಳಿಲ್ಲದೆ ಡೇಟಾಬೇಸ್ ರಚನೆಯಲ್ಲಿನ ಬದಲಾವಣೆಗಳನ್ನು ಇತರ ಪರಿಸರಗಳಿಗೆ ವರ್ಗಾಯಿಸುವುದು ಹೇಗೆ
4. ಹಲವಾರು ಡೆವಲಪರ್‌ಗಳಿಂದ ಪ್ರಾಜೆಕ್ಟ್‌ನಲ್ಲಿ ಸಮಾನಾಂತರ ಕೆಲಸದ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಹೇಗೆ ಸಂಘಟಿಸುವುದು
5. ಉತ್ಪಾದನಾ ಪರಿಸರಕ್ಕೆ ಡೇಟಾಬೇಸ್ ರಚನೆಯಲ್ಲಿ ಹೆಚ್ಚಿನ ಬದಲಾವಣೆಗಳನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ನಿಯೋಜಿಸುವುದು ಹೇಗೆ
   

   ಸ್ಕೀಮಾಕೀಪರ್ ಭಾಷೆಯಲ್ಲಿ ಬರೆಯಲಾದ ಸಂಗ್ರಹಿಸಿದ ಕಾರ್ಯವಿಧಾನಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ PL/pgSQL. ಇತರ ಭಾಷೆಗಳೊಂದಿಗೆ ಪರೀಕ್ಷೆಯನ್ನು ನಡೆಸಲಾಗಿಲ್ಲ, ಆದ್ದರಿಂದ ಬಳಕೆಯು ಪರಿಣಾಮಕಾರಿಯಾಗದಿರಬಹುದು ಅಥವಾ ಸಾಧ್ಯವಾಗದಿರಬಹುದು.

VCS ನಲ್ಲಿ ಡೇಟಾಬೇಸ್ ರಚನೆ ಡಂಪ್ ಅನ್ನು ಹೇಗೆ ಸಂಗ್ರಹಿಸುವುದು

ಗ್ರಂಥಾಲಯದ ಸ್ಕೀಮಾ-ಕೀಪರ್ ಒಂದು ಕಾರ್ಯವನ್ನು ಒದಗಿಸುತ್ತದೆ saveDump, ಇದು ಡೇಟಾಬೇಸ್‌ನಿಂದ ಎಲ್ಲಾ ವಸ್ತುಗಳ ರಚನೆಯನ್ನು ಪ್ರತ್ಯೇಕ ಪಠ್ಯ ಫೈಲ್‌ಗಳಾಗಿ ಉಳಿಸುತ್ತದೆ. ಔಟ್‌ಪುಟ್ ಎನ್ನುವುದು ಡೇಟಾಬೇಸ್ ರಚನೆಯನ್ನು ಒಳಗೊಂಡಿರುವ ಡೈರೆಕ್ಟರಿಯಾಗಿದೆ, ಇದನ್ನು ಗುಂಪು ಮಾಡಿದ ಫೈಲ್‌ಗಳಾಗಿ ವಿಂಗಡಿಸಲಾಗಿದೆ, ಅದನ್ನು ಸುಲಭವಾಗಿ VCS ಗೆ ಸೇರಿಸಬಹುದು.

ಹಲವಾರು ಉದಾಹರಣೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಡೇಟಾಬೇಸ್‌ನಿಂದ ವಸ್ತುಗಳನ್ನು ಫೈಲ್‌ಗಳಾಗಿ ಪರಿವರ್ತಿಸುವುದನ್ನು ನೋಡೋಣ:

ವಸ್ತುವಿನ ಪ್ರಕಾರ
ಯೋಜನೆ
ಶೀರ್ಷಿಕೆ
ಫೈಲ್ಗೆ ಸಂಬಂಧಿತ ಮಾರ್ಗ

ಟೇಬಲ್
ಸಾರ್ವಜನಿಕ
ಖಾತೆಗಳನ್ನು
./public/tables/accounts.txt

ಸಂಗ್ರಹಿಸಿದ ಕಾರ್ಯವಿಧಾನ
ಸಾರ್ವಜನಿಕ
ದೃಢೀಕರಣ (ಹ್ಯಾಶ್ ಬಿಗಿಂಟ್)
./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 ನಲ್ಲಿನ ಪ್ರತಿಯೊಂದು ಶಾಖೆಯು ಡಂಪ್‌ನ ತನ್ನದೇ ಆದ ಆವೃತ್ತಿಯನ್ನು ಹೊಂದಿರುತ್ತದೆ ಮತ್ತು ಶಾಖೆಗಳನ್ನು ವಿಲೀನಗೊಳಿಸುವಾಗ, ಡಂಪ್‌ಗಳನ್ನು ವಿಲೀನಗೊಳಿಸಲಾಗುತ್ತದೆ. ಹೆಚ್ಚಿನ ಸಂದರ್ಭಗಳಲ್ಲಿ, ವಿಲೀನದ ನಂತರ ಯಾವುದೇ ಹೆಚ್ಚುವರಿ ಕ್ರಮಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಬೇಕಾಗಿಲ್ಲ, ಆದರೆ ವಿಭಿನ್ನ ಶಾಖೆಗಳಲ್ಲಿ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಿದರೆ, ಉದಾಹರಣೆಗೆ ಒಂದೇ ಕೋಷ್ಟಕಕ್ಕೆ, ಸಂಘರ್ಷ ಉಂಟಾಗಬಹುದು.

ಉದಾಹರಣೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಸಂಘರ್ಷದ ಪರಿಸ್ಥಿತಿಯನ್ನು ಪರಿಗಣಿಸೋಣ: ಒಂದು ಶಾಖೆ ಇದೆ ಅಭಿವೃದ್ಧಿ, ಎರಡು ಶಾಖೆಗಳಿಂದ ಶಾಖೆಗಳು: feature1 и feature2, ಇದು ಯಾವುದೇ ಘರ್ಷಣೆಯನ್ನು ಹೊಂದಿಲ್ಲ ಅಭಿವೃದ್ಧಿ, ಆದರೆ ಪರಸ್ಪರ ಘರ್ಷಣೆಗಳಿವೆ. ಎರಡೂ ಶಾಖೆಗಳನ್ನು ವಿಲೀನಗೊಳಿಸುವುದು ಕಾರ್ಯವಾಗಿದೆ ಅಭಿವೃದ್ಧಿ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಮೊದಲು ಶಾಖೆಗಳಲ್ಲಿ ಒಂದನ್ನು ವಿಲೀನಗೊಳಿಸಲು ಸೂಚಿಸಲಾಗುತ್ತದೆ ಅಭಿವೃದ್ಧಿತದನಂತರ ವಿಲೀನಗೊಳಿಸಿ ಅಭಿವೃದ್ಧಿ ಉಳಿದ ಶಾಖೆಗೆ, ಉಳಿದ ಶಾಖೆಯಲ್ಲಿನ ಘರ್ಷಣೆಗಳನ್ನು ಪರಿಹರಿಸುವುದು ಮತ್ತು ನಂತರ ಕೊನೆಯ ಶಾಖೆಯನ್ನು ವಿಲೀನಗೊಳಿಸುವುದು ಅಭಿವೃದ್ಧಿ. ಸಂಘರ್ಷ ಪರಿಹಾರದ ಹಂತದಲ್ಲಿ, ನೀವು ಕೊನೆಯ ಶಾಖೆಯಲ್ಲಿ ವಲಸೆ ಫೈಲ್ ಅನ್ನು ಸರಿಪಡಿಸಬೇಕಾಗಬಹುದು ಇದರಿಂದ ಅದು ವಿಲೀನಗಳ ಫಲಿತಾಂಶಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಅಂತಿಮ ಡಂಪ್‌ಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ.

ಉತ್ಪಾದನಾ ಪರಿಸರಕ್ಕೆ ಡೇಟಾಬೇಸ್ ರಚನೆಯಲ್ಲಿ ಹೆಚ್ಚಿನ ಬದಲಾವಣೆಗಳನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ನಿಯೋಜಿಸುವುದು ಹೇಗೆ

VCS ನಲ್ಲಿ ಪ್ರಸ್ತುತ ಡೇಟಾಬೇಸ್ ರಚನೆಯ ಡಂಪ್ ಇರುವಿಕೆಗೆ ಧನ್ಯವಾದಗಳು, ಅಗತ್ಯವಿರುವ ರಚನೆಯೊಂದಿಗೆ ನಿಖರವಾದ ಅನುಸರಣೆಗಾಗಿ ಉತ್ಪಾದನಾ ಡೇಟಾಬೇಸ್ ಅನ್ನು ಪರಿಶೀಲಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ. ಡೆವಲಪರ್‌ಗಳು ಉದ್ದೇಶಿಸಿರುವ ಎಲ್ಲಾ ಬದಲಾವಣೆಗಳನ್ನು ಯಶಸ್ವಿಯಾಗಿ ಉತ್ಪಾದನಾ ನೆಲೆಗೆ ವರ್ಗಾಯಿಸಲಾಗಿದೆ ಎಂದು ಇದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

ರಿಂದ ಡಿಡಿಎಲ್ PostgreSQL ನಲ್ಲಿದೆ ವಹಿವಾಟಿನ, ಈ ಕೆಳಗಿನ ನಿಯೋಜನೆಯ ಕ್ರಮಕ್ಕೆ ಬದ್ಧವಾಗಿರಲು ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ, ಆದ್ದರಿಂದ ಅನಿರೀಕ್ಷಿತ ದೋಷದ ಸಂದರ್ಭದಲ್ಲಿ, ನೀವು "ನೋವುರಹಿತವಾಗಿ" ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು ROLLBACK:

1. ವಹಿವಾಟು ಪ್ರಾರಂಭಿಸಿ
2. ವಹಿವಾಟಿನಲ್ಲಿ ಎಲ್ಲಾ ವಲಸೆಗಳನ್ನು ನಿರ್ವಹಿಸಿ
3. ಅದೇ ವಹಿವಾಟಿನಲ್ಲಿ, ಕಾರ್ಯಗತಗೊಳಿಸಿ deployDump
4. ವಹಿವಾಟನ್ನು ಪೂರ್ಣಗೊಳಿಸದೆ, ಕಾರ್ಯಗತಗೊಳಿಸಿ verifyDump. ಯಾವುದೇ ದೋಷಗಳಿಲ್ಲದಿದ್ದರೆ, ರನ್ ಮಾಡಿ COMMIT. ದೋಷಗಳಿದ್ದರೆ, ರನ್ ಮಾಡಿ ROLLBACK

ಶೂನ್ಯ-ಅಲಭ್ಯತೆಯನ್ನು ಒಳಗೊಂಡಂತೆ ಅಪ್ಲಿಕೇಶನ್ ನಿಯೋಜನೆಗೆ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ವಿಧಾನಗಳಿಗೆ ಈ ಹಂತಗಳನ್ನು ಸುಲಭವಾಗಿ ಸಂಯೋಜಿಸಬಹುದು.

ತೀರ್ಮಾನಕ್ಕೆ

ಮೇಲೆ ವಿವರಿಸಿದ ವಿಧಾನಗಳಿಗೆ ಧನ್ಯವಾದಗಳು, "PHP + PostgreSQL" ಯೋಜನೆಗಳಿಂದ ಗರಿಷ್ಠ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಹಿಂಡುವ ಸಾಧ್ಯತೆಯಿದೆ, ಆದರೆ ಮುಖ್ಯ ಅಪ್ಲಿಕೇಶನ್ ಕೋಡ್‌ನಲ್ಲಿ ಎಲ್ಲಾ ವ್ಯವಹಾರ ತರ್ಕವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದಕ್ಕೆ ಹೋಲಿಸಿದರೆ ತುಲನಾತ್ಮಕವಾಗಿ ಕಡಿಮೆ ಅಭಿವೃದ್ಧಿ ಅನುಕೂಲವನ್ನು ತ್ಯಾಗ ಮಾಡುವುದು. ಇದಲ್ಲದೆ, ಡೇಟಾ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ PL/pgSQL ಸಾಮಾನ್ಯವಾಗಿ ಹೆಚ್ಚು ಪಾರದರ್ಶಕವಾಗಿ ಕಾಣುತ್ತದೆ ಮತ್ತು PHP ನಲ್ಲಿ ಬರೆಯಲಾದ ಅದೇ ಕ್ರಿಯಾತ್ಮಕತೆಗಿಂತ ಕಡಿಮೆ ಕೋಡ್ ಅಗತ್ಯವಿರುತ್ತದೆ.

ಮೂಲ: www.habr.com