ನೀವು ದಿನನಿತ್ಯದ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಮತ್ತೆ ಮತ್ತೆ ಪುನರಾವರ್ತಿಸಲು ಇಷ್ಟಪಡುತ್ತೀರಾ? ಹಾಗಾಗಿ ನಾನು ಮಾಡುವುದಿಲ್ಲ. ಆದರೆ SQL ಕ್ಲೈಂಟ್‌ನಲ್ಲಿ ಪ್ರತಿ ಬಾರಿ ರೋಸ್ಟೆಲೆಕಾಮ್ ಸಂಗ್ರಹಣೆಯೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ನಾನು ಕೋಷ್ಟಕಗಳ ನಡುವಿನ ಎಲ್ಲಾ ಸೇರ್ಪಡೆಗಳನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ನೋಂದಾಯಿಸಬೇಕಾಗಿತ್ತು. ಮತ್ತು 90% ಪ್ರಕರಣಗಳಲ್ಲಿ ಕೋಷ್ಟಕಗಳನ್ನು ಸೇರುವ ಕ್ಷೇತ್ರಗಳು ಮತ್ತು ಷರತ್ತುಗಳು ಪ್ರಶ್ನೆಯಿಂದ ಪ್ರಶ್ನೆಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತವೆ ಎಂಬ ಅಂಶದ ಹೊರತಾಗಿಯೂ! ಯಾವುದೇ SQL ಕ್ಲೈಂಟ್ ಸ್ವಯಂ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆ ಕಾರ್ಯಗಳನ್ನು ಹೊಂದಿದೆ ಎಂದು ತೋರುತ್ತದೆ, ಆದರೆ ಸಂಗ್ರಹಣೆಗಳಿಗೆ ಇದು ಯಾವಾಗಲೂ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ: ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸಲು ಅವು ಅಪರೂಪವಾಗಿ ಅನನ್ಯ ನಿರ್ಬಂಧ ಮತ್ತು ವಿದೇಶಿ ಕೀಲಿಯನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ ಮತ್ತು ಇದು ಇಲ್ಲದೆ ಪ್ರತಿಯೊಂದಕ್ಕೂ ಘಟಕಗಳು ಹೇಗೆ ಸಂಬಂಧಿಸಿವೆ ಎಂದು ಪ್ರೋಗ್ರಾಂಗೆ ತಿಳಿದಿರುವುದಿಲ್ಲ. ಇತರ ಮತ್ತು ನೀವು ನೀಡುವ ಕೊಡುಗೆಗಾಗಿ ಅದು ಏನು ಮಾಡಬಹುದು.
ನಿರಾಕರಣೆ, ಕೋಪ, ಚೌಕಾಶಿ, ಖಿನ್ನತೆ ಮತ್ತು ಸ್ವೀಕಾರವನ್ನು ಸಮೀಪಿಸುತ್ತಿರುವಾಗ, ನಾನು ನಿರ್ಧರಿಸಿದೆ - ಬ್ಲ್ಯಾಕ್‌ಜಾಕ್‌ನೊಂದಿಗೆ ಸ್ವಯಂ ಭರ್ತಿ ಮಾಡಲು ನಾನೇ ಏಕೆ ಪ್ರಯತ್ನಿಸಬಾರದು ಮತ್ತು ಅದನ್ನು ಸರಿಯಾದ ರೀತಿಯಲ್ಲಿ ಮಾಡಬಾರದು? ನಾನು ಜಾವಾದಲ್ಲಿ ಬರೆದ dbeaver ಕ್ಲೈಂಟ್ ಅನ್ನು ಬಳಸುತ್ತೇನೆ, ಇದು ಮುಕ್ತ ಮೂಲ ಸಮುದಾಯ ಆವೃತ್ತಿಯನ್ನು ಹೊಂದಿದೆ. ಸರಳವಾದ ಯೋಜನೆಯು ಪ್ರಬುದ್ಧವಾಗಿದೆ:
- ಸ್ವಯಂ ಪೂರ್ಣಗೊಳಿಸುವಿಕೆಗೆ ಕಾರಣವಾಗಿರುವ ಮೂಲ ಕೋಡ್‌ನಲ್ಲಿ ತರಗತಿಗಳನ್ನು ಹುಡುಕಿ
- ಬಾಹ್ಯ ಮೆಟಾಡೇಟಾದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಅವುಗಳನ್ನು ಮರುನಿರ್ದೇಶಿಸಿ ಮತ್ತು ಅಲ್ಲಿಂದ ಸೇರುವ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಎಳೆಯಿರಿ
- ??????
- ಲಾಭ
ನಾನು ಮೊದಲ ಅಂಶವನ್ನು ತ್ವರಿತವಾಗಿ ಕಂಡುಕೊಂಡಿದ್ದೇನೆ - ಸ್ವಯಂತುಂಬುವಿಕೆಯನ್ನು ಸರಿಹೊಂದಿಸಲು ಬಗ್ ಟ್ರ್ಯಾಕರ್‌ನಲ್ಲಿ ಮತ್ತು ಸಂಬಂಧಿತವಾದ ವಿನಂತಿಯನ್ನು ನಾನು ಕಂಡುಕೊಂಡಿದ್ದೇನೆ SQLCcompletionAnalyzer ವರ್ಗವನ್ನು ಕಂಡುಹಿಡಿದರು. ನಾನು ಕೋಡ್ ಅನ್ನು ನೋಡಿದೆ ಮತ್ತು ಅದು ನನಗೆ ಬೇಕಾಗಿರುವುದು. ಎಲ್ಲವೂ ಕೆಲಸ ಮಾಡುವಂತೆ ಅದನ್ನು ಪುನಃ ಬರೆಯುವುದು ಮಾತ್ರ ಉಳಿದಿದೆ. ನಾನು ಉಚಿತ ಸಂಜೆಗಾಗಿ ಕಾಯುತ್ತಿದ್ದೆ ಮತ್ತು ಅನುಷ್ಠಾನದ ಮೂಲಕ ಯೋಚಿಸಲು ಪ್ರಾರಂಭಿಸಿದೆ. ನಾನು json ನಲ್ಲಿ ಟೇಬಲ್ ಲಿಂಕ್ ನಿಯಮಗಳನ್ನು (ಮೆಟಾಡೇಟಾ) ಬರೆಯಲು ನಿರ್ಧರಿಸಿದೆ. ಈ ಸ್ವರೂಪದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಪ್ರಾಯೋಗಿಕ ಅನುಭವವನ್ನು ನಾನು ಹೊಂದಿರಲಿಲ್ಲ ಮತ್ತು ಪ್ರಸ್ತುತ ಕಾರ್ಯವು ಈ ಲೋಪವನ್ನು ಸರಿಪಡಿಸಲು ಒಂದು ಅವಕಾಶವಾಗಿ ಕಂಡುಬಂದಿದೆ.
json ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ನಾನು ಲೈಬ್ರರಿಯನ್ನು ಬಳಸಲು ನಿರ್ಧರಿಸಿದೆ Google ನಿಂದ. ಇಲ್ಲಿಂದ ಆಶ್ಚರ್ಯಗಳು ಪ್ರಾರಂಭವಾದವು. ಅದು ಬದಲಾದಂತೆ, dbeaver, ನಿಜವಾದ ಅಪ್ಲಿಕೇಶನ್‌ನಂತೆ, OSGi ಫ್ರೇಮ್‌ವರ್ಕ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಎಕ್ಲಿಪ್ಸ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ. ಅನುಭವಿ ಡೆವಲಪರ್‌ಗಳಿಗೆ, ಈ ವಿಷಯವು ಅವಲಂಬನೆಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಅನುಕೂಲಕರವಾಗಿದೆ, ಆದರೆ ನನಗೆ ಇದು ಡಾರ್ಕ್ ಮ್ಯಾಜಿಕ್‌ನಂತಿದೆ, ಇದಕ್ಕಾಗಿ ನಾನು ಸ್ಪಷ್ಟವಾಗಿ ಸಿದ್ಧವಾಗಿಲ್ಲ: ಎಂದಿನಂತೆ, ನಾನು ಹೆಡರ್‌ನಲ್ಲಿರುವ json-simple ಲೈಬ್ರರಿಯಿಂದ ನನಗೆ ಅಗತ್ಯವಿರುವ ತರಗತಿಗಳನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳುತ್ತೇನೆ. ಸಂಪಾದಿಸಿದ ವರ್ಗ, ಅದನ್ನು pom. xml ನಲ್ಲಿ ಸೂಚಿಸಿ, ಅದರ ನಂತರ ಯೋಜನೆಯು ಸಾಮಾನ್ಯವಾಗಿ ಜೋಡಿಸಲು ನಿರಾಕರಿಸುತ್ತದೆ ಮತ್ತು ದೋಷಗಳೊಂದಿಗೆ ಕ್ರ್ಯಾಶ್ ಆಗುತ್ತದೆ.
ಕೊನೆಯಲ್ಲಿ, ನಾನು ಬಿಲ್ಡ್ ದೋಷಗಳನ್ನು ಸರಿಪಡಿಸಲು ನಿರ್ವಹಿಸುತ್ತಿದ್ದೆ: ನಾನು ಲೈಬ್ರರಿಯನ್ನು pom.xml ನಲ್ಲಿ ಅಲ್ಲ, ಆದರೆ OSGI ಗೆ ಅಗತ್ಯವಿರುವ ಮ್ಯಾನಿಫೆಸ್ಟ್.mf ಮ್ಯಾನಿಫೆಸ್ಟ್‌ನಲ್ಲಿ ಆಮದು-ಪ್ಯಾಕೇಜ್ ಎಂದು ನಿರ್ದಿಷ್ಟಪಡಿಸುವಾಗ ನೋಂದಾಯಿಸಿದ್ದೇನೆ. ಅತ್ಯಂತ ಸುಂದರವಾದ ಪರಿಹಾರವಲ್ಲ, ಆದರೆ ಅದು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ನಂತರ ಮುಂದಿನ ಆಶ್ಚರ್ಯ ಕಾಣಿಸಿಕೊಂಡಿತು. ನೀವು ಇಂಟೆಲಿಜ್ ಐಡಿಯಾದಲ್ಲಿ ಅಭಿವೃದ್ಧಿಪಡಿಸುತ್ತಿದ್ದರೆ, ನೀವು ಗ್ರಹಣ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಅನ್ನು ಆಧರಿಸಿ ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್ ಅನ್ನು ಡೀಬಗ್ ಮಾಡಲು ಹೋಗಿ ಪ್ರಾರಂಭಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ: ಅನನುಭವಿ ಡೆವಲಪರ್ ಪ್ರಶ್ನೆಯನ್ನು ಪೂರ್ಣಗೊಳಿಸದೆ ವಿಶ್ಲೇಷಕಕ್ಕಿಂತ ಕಡಿಮೆಯಿಲ್ಲ. ಬೀವರ್ ಡೆವಲಪರ್‌ಗಳು ಸ್ವತಃ ಪಾರುಗಾಣಿಕಾಕ್ಕೆ ಬಂದರು, ವಿಕಿಯಲ್ಲಿ ಮಾಡಬೇಕಾದ ಎಲ್ಲಾ ನೃತ್ಯಗಳನ್ನು ಟಾಂಬೊರಿನ್‌ನೊಂದಿಗೆ ಸೂಚಿಸುತ್ತದೆ. ಅತ್ಯಂತ ಕಿರಿಕಿರಿಯುಂಟುಮಾಡುವ ಸಂಗತಿಯೆಂದರೆ, ಈ ಎಲ್ಲಾ ಸ್ಕ್ವಾಟ್‌ಗಳ ನಂತರವೂ, ಆಮದು-ಪ್ಯಾಕೇಜ್ ಮೂಲಕ ಸಂಪರ್ಕಗೊಂಡಿರುವ json ಲೈಬ್ರರಿಯೊಂದಿಗೆ ಡೀಬಗ್‌ನಲ್ಲಿ ಯೋಜನೆಯನ್ನು ಪ್ರಾರಂಭಿಸಲು ಬಯಸುವುದಿಲ್ಲ (ಇದು ಇನ್ನೂ ಸಿದ್ಧಪಡಿಸಿದ ಉತ್ಪನ್ನಕ್ಕೆ ಯಶಸ್ವಿಯಾಗಿ ಜೋಡಿಸಲ್ಪಟ್ಟಿದ್ದರೂ ಸಹ).
ಆ ಹೊತ್ತಿಗೆ, ನನ್ನ ಕಾರ್ಯಕ್ಕಾಗಿ json ಅನ್ನು ಬಳಸುವ ಅನಾನುಕೂಲತೆಯನ್ನು ನಾನು ಈಗಾಗಲೇ ಅರಿತುಕೊಂಡೆ - ಎಲ್ಲಾ ನಂತರ, ಮೆಟಾಡೇಟಾವನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ಸಂಪಾದಿಸಬೇಕಾಗಿತ್ತು ಮತ್ತು xml ಸ್ವರೂಪವು ಇದಕ್ಕೆ ಹೆಚ್ಚು ಸೂಕ್ತವಾಗಿದೆ. Xml ಪರವಾಗಿ ಎರಡನೇ ವಾದವು JDK ನಲ್ಲಿ ಎಲ್ಲಾ ಅಗತ್ಯ ವರ್ಗಗಳ ಉಪಸ್ಥಿತಿಯಾಗಿದೆ, ಇದು ಬಾಹ್ಯ ಗ್ರಂಥಾಲಯದೊಂದಿಗೆ ಹೋರಾಡುವುದನ್ನು ನಿಲ್ಲಿಸಲು ಸಾಧ್ಯವಾಗಿಸಿತು. ಬಹಳ ಸಂತೋಷದಿಂದ, ನಾನು ಎಲ್ಲಾ ಮೆಟಾಡೇಟಾವನ್ನು json ನಿಂದ xml ಗೆ ವರ್ಗಾಯಿಸಿದೆ ಮತ್ತು ಸ್ವಯಂಪೂರ್ಣತೆಯ ತರ್ಕವನ್ನು ಸಂಪಾದಿಸಲು ಪ್ರಾರಂಭಿಸಿದೆ.
ಮೆಟಾಡೇಟಾ ಉದಾಹರಣೆ
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<tableRelations>
<tableRelation>
<leftTable>dim_account</leftTable>
<rightTable>dim_partner</rightTable>
<joinColumnPair leftColumn="partner_key" rightColumn="partner_key"/>
<joinColumnPair leftColumn="src_id" rightColumn="src_id"/>
</tableRelation>
<tableRelation>
<leftTable>dim_account</leftTable>
<rightTable>dim_branch</rightTable>
<joinColumnPair leftColumn="src_id" rightColumn="src_id"/>
<joinColumnPair leftColumn="branch_key" rightColumn="branch_key"/>
</tableRelation>
</tableRelations>ಪರಿಣಾಮವಾಗಿ ಐ SQLUtils ಮತ್ತು SQLCcompletionAnalyzer ತರಗತಿಗಳಿಗೆ. ಕಲ್ಪನೆಯು ಹೀಗಿದೆ: ಮೂಲ ತರ್ಕವನ್ನು ಬಳಸಿಕೊಂಡು ಸೂಕ್ತವಾದ ಸ್ವಯಂಪೂರ್ಣತೆ ಸಲಹೆಗಳನ್ನು ಕಂಡುಹಿಡಿಯಲು ಪ್ರೋಗ್ರಾಂಗೆ ಸಾಧ್ಯವಾಗದಿದ್ದರೆ, ಬಾಹ್ಯ xml ಫೈಲ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಸಂಭವನೀಯ ಸೇರ್ಪಡೆಗಳ ಉಪಸ್ಥಿತಿಯನ್ನು ಅದು ಪರಿಶೀಲಿಸುತ್ತದೆ. ಈ ಕೋಷ್ಟಕಗಳನ್ನು ಲಿಂಕ್ ಮಾಡಬೇಕಾದ ಕ್ಷೇತ್ರಗಳನ್ನು ಸೂಚಿಸುವ ಜೋಡಿ ಕೋಷ್ಟಕಗಳನ್ನು ಫೈಲ್ ಸ್ವತಃ ಸಂಗ್ರಹಿಸುತ್ತದೆ. eff_dttm ಮತ್ತು exp_dttm ದಾಖಲೆಗಳ ತಾಂತ್ರಿಕ ಮಾನ್ಯತೆಯ ದಿನಾಂಕಗಳ ಮೇಲಿನ ನಿರ್ಬಂಧಗಳು ಮತ್ತು ತಾರ್ಕಿಕ ಅಳಿಸುವಿಕೆ ಫ್ಲ್ಯಾಗ್ deleted_ind ಅನ್ನು ಡಿಫಾಲ್ಟ್ ಆಗಿ ಹೊಂದಿಸಲಾಗಿದೆ.
ಕೋಡ್‌ಗೆ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಿದಾಗ, ಪ್ರಶ್ನೆ ಉದ್ಭವಿಸಿತು - ಮೆಟಾಡೇಟಾದೊಂದಿಗೆ ಫೈಲ್ ಅನ್ನು ಯಾರು ತುಂಬುತ್ತಾರೆ? ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಬಹಳಷ್ಟು ಘಟಕಗಳಿವೆ, ಎಲ್ಲಾ ಸಂಪರ್ಕಗಳನ್ನು ನೀವೇ ನೋಂದಾಯಿಸಲು ಇದು ದುಬಾರಿಯಾಗಿದೆ. ಪರಿಣಾಮವಾಗಿ, ನಾನು ಈ ಕೆಲಸವನ್ನು ನನ್ನ ಸಹ ವಿಶ್ಲೇಷಕರಿಗೆ ನಿಯೋಜಿಸಲು ನಿರ್ಧರಿಸಿದೆ. ನಾನು ಮೆಟಾಡೇಟಾ ಫೈಲ್ ಅನ್ನು svn ನಲ್ಲಿ ಪೋಸ್ಟ್ ಮಾಡಿದ್ದೇನೆ, ಅಲ್ಲಿಂದ ಪ್ರೋಗ್ರಾಂನೊಂದಿಗೆ ಸ್ಥಳೀಯ ಡೈರೆಕ್ಟರಿಗೆ ಚೆಕ್ಔಟ್ ಮಾಡಲಾಗಿದೆ. ತತ್ವ ಇದು: ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಹೊಸ ಘಟಕ ಕಾಣಿಸಿಕೊಂಡಿದೆಯೇ? ಒಬ್ಬ ವಿಶ್ಲೇಷಕನು ಫೈಲ್‌ಗೆ ಸಂಭವನೀಯ ಸೇರ್ಪಡೆಗಳನ್ನು ಪ್ರವೇಶಿಸುತ್ತಾನೆ, ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡುತ್ತಾನೆ, ಉಳಿದವರು ತಮ್ಮನ್ನು ತಾವು ಪರಿಶೀಲಿಸಿಕೊಳ್ಳುತ್ತಾರೆ ಮತ್ತು ಕೆಲಸ ಮಾಡುವ ಸ್ವಯಂ-ಪೂರ್ಣತೆಯನ್ನು ಆನಂದಿಸುತ್ತಾರೆ: ಸಮುದಾಯ, ಜ್ಞಾನದ ಸಂಗ್ರಹಣೆ ಮತ್ತು ಎಲ್ಲವೂ. ಸಹೋದ್ಯೋಗಿಗಳಿಗಾಗಿ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಬಳಸುವ ಕುರಿತು ಕಾರ್ಯಾಗಾರವನ್ನು ನಡೆಸಿದರು, ಸಂಗಮದಲ್ಲಿ ಒಂದು ಲೇಖನವನ್ನು ಬರೆದರು - ಈಗ ಕಂಪನಿಯು ಹೆಚ್ಚು ಅನುಕೂಲಕರ ಸಾಧನವನ್ನು ಹೊಂದಿದೆ.
ಈ ವೈಶಿಷ್ಟ್ಯದಲ್ಲಿ ಕೆಲಸ ಮಾಡುವುದರಿಂದ ತೆರೆದ ಮೂಲ ಯೋಜನೆಗಳೊಂದಿಗೆ ಟಿಂಕರ್ ಮಾಡಲು ಭಯಪಡುವ ಅಗತ್ಯವಿಲ್ಲ ಎಂದು ನನಗೆ ತಿಳುವಳಿಕೆ ನೀಡಿತು - ನಿಯಮದಂತೆ, ಅವರು ಸ್ಪಷ್ಟವಾದ ವಾಸ್ತುಶಿಲ್ಪವನ್ನು ಹೊಂದಿದ್ದಾರೆ ಮತ್ತು ಭಾಷೆಯ ಮೂಲಭೂತ ಜ್ಞಾನವೂ ಪ್ರಯೋಗಗಳಿಗೆ ಸಾಕಾಗುತ್ತದೆ. ಮತ್ತು ಒಂದು ನಿರ್ದಿಷ್ಟ ಪ್ರಮಾಣದ ನಿರಂತರತೆಯೊಂದಿಗೆ, ನೀವು ದ್ವೇಷಿಸುತ್ತಿದ್ದ ವಾಡಿಕೆಯ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ತೊಡೆದುಹಾಕಲು ಸಹ ಸಾಧ್ಯವಾಗುತ್ತದೆ, ಹೊಸ ಪ್ರಯೋಗಗಳಿಗಾಗಿ ನಿಮ್ಮ ಸಮಯವನ್ನು ಉಳಿಸಬಹುದು.
ಮೂಲ: www.habr.com