అదే పనిని ఎలా ఆపాలి

మీరు సాధారణ కార్యకలాపాలను మళ్లీ మళ్లీ పునరావృతం చేయాలనుకుంటున్నారా? కాబట్టి నేను చేయను. కానీ ప్రతిసారీ SQL క్లయింట్‌లో Rostelecom నిల్వతో పని చేస్తున్నప్పుడు, నేను పట్టికల మధ్య అన్ని చేరికలను మాన్యువల్‌గా నమోదు చేయాల్సి వచ్చింది. మరియు ఇది 90% కేసులలో పట్టికలలో చేరడానికి ఫీల్డ్‌లు మరియు షరతులు అభ్యర్థన నుండి అభ్యర్థన వరకు సమానంగా ఉన్నప్పటికీ! ఏదైనా SQL క్లయింట్ స్వీయ-పూర్తి ఫంక్షన్‌లను కలిగి ఉన్నట్లు అనిపిస్తుంది, కానీ నిల్వల కోసం ఇది ఎల్లప్పుడూ పని చేయదు: పనితీరును మెరుగుపరచడానికి అవి చాలా అరుదుగా ప్రత్యేకమైన పరిమితి మరియు విదేశీ కీని కలిగి ఉంటాయి మరియు ఇది లేకుండా ప్రతిదానికి ఎంటిటీలు ఎలా సంబంధం కలిగి ఉన్నాయో ప్రోగ్రామ్‌కు తెలియదు. ఇతర మరియు మీ ఆఫర్ కోసం అది ఏమి చేయగలదు.

తిరస్కరణ, కోపం, బేరసారాలు, నిరాశ మరియు అంగీకారానికి చేరుకోవడం వంటి వాటి ద్వారా వెళ్ళిన తర్వాత, నేను నిర్ణయించుకున్నాను - బ్లాక్‌జాక్‌తో ఆటోఫిల్‌ని నేనే అమలు చేసి సరైన మార్గంలో ఎందుకు చేయకూడదు? నేను జావాలో వ్రాసిన dbeaver క్లయింట్‌ని ఉపయోగిస్తాను, దీనికి ఓపెన్ సోర్స్ కమ్యూనిటీ వెర్షన్ ఉంది. ఒక సాధారణ ప్రణాళిక పరిపక్వం చెందింది:

1. స్వీయపూర్తికి బాధ్యత వహించే తరగతులను సోర్స్ కోడ్‌లో కనుగొనండి
2. వాటిని బాహ్య మెటాడేటాతో పని చేయడానికి దారి మళ్లించండి మరియు చేరడం గురించి సమాచారాన్ని అక్కడ నుండి లాగండి
3. ??????
4. రాబడి

నేను మొదటి పాయింట్‌ను చాలా త్వరగా గుర్తించాను - ఆటోఫిల్‌ని సర్దుబాటు చేయడానికి బగ్ ట్రాకర్‌లో మరియు సంబంధిత విషయాలలో నేను అభ్యర్థనను కనుగొన్నాను కట్టుబడి SQLCcompletionAnalyzer తరగతిని కనుగొన్నారు. నేను కోడ్‌ని చూశాను మరియు అది నాకు అవసరం. ప్రతిదీ పని చేసేలా దాన్ని తిరిగి వ్రాయడమే మిగిలి ఉంది. నేను ఉచిత సాయంత్రం కోసం వేచి ఉన్నాను మరియు అమలు గురించి ఆలోచించడం ప్రారంభించాను. నేను jsonలో టేబుల్ లింక్ నియమాలను (మెటాడేటా) వ్రాయాలని నిర్ణయించుకున్నాను. ఈ ఫార్మాట్‌తో పని చేసిన నాకు ఆచరణాత్మక అనుభవం లేదు మరియు ప్రస్తుత పని ఈ లోపాన్ని సరిదిద్దడానికి ఒక అవకాశంగా భావించబడింది.

jsonతో పని చేయడానికి నేను లైబ్రరీని ఉపయోగించాలని నిర్ణయించుకున్నాను json-సింపుల్ Google నుండి. ఇక్కడే ఆశ్చర్యాలు మొదలయ్యాయి. ఇది ముగిసినట్లుగా, dbeaver, నిజమైన అప్లికేషన్‌గా, OSGi ఫ్రేమ్‌వర్క్‌ని ఉపయోగించి ఎక్లిప్స్ ప్లాట్‌ఫారమ్‌లో వ్రాయబడింది. అనుభవజ్ఞులైన డెవలపర్‌ల కోసం, ఈ విషయం డిపెండెన్సీలను నిర్వహించడం సౌకర్యంగా ఉంటుంది, కానీ నాకు ఇది డార్క్ మ్యాజిక్ లాగా ఉంది, దాని కోసం నేను స్పష్టంగా సిద్ధంగా లేను: ఎప్పటిలాగే, నేను హెడర్‌లోని json-సింపుల్ లైబ్రరీ నుండి నాకు అవసరమైన తరగతులను దిగుమతి చేసుకుంటాను. సవరించిన తరగతి, దానిని pom. xmlలో పేర్కొనండి, ఆ తర్వాత ప్రాజెక్ట్ సాధారణంగా సమీకరించడాన్ని నిరాకరిస్తుంది మరియు లోపాలతో క్రాష్ అవుతుంది.

చివరికి, నేను బిల్డ్ ఎర్రర్‌లను పరిష్కరించగలిగాను: నేను లైబ్రరీని pom.xmlలో కాకుండా మానిఫెస్ట్.mf మానిఫెస్ట్‌లో నమోదు చేసాను, OSGIకి అవసరమైన విధంగా, దానిని దిగుమతి-ప్యాకేజీగా పేర్కొంటూ. చాలా అందమైన పరిష్కారం కాదు, కానీ అది పనిచేస్తుంది. అప్పుడు తదుపరి ఆశ్చర్యం కనిపించింది. మీరు Intellij Ideaలో అభివృద్ధి చెందుతున్నట్లయితే, మీరు కేవలం ఎక్లిప్స్ ప్లాట్‌ఫారమ్ ఆధారంగా మీ ప్రాజెక్ట్‌ని డీబగ్గింగ్ చేయడం ప్రారంభించలేరు: అనుభవం లేని డెవలపర్ ప్రశ్నను పూర్తి చేయకుండానే విశ్లేషకుడి కంటే తక్కువ కాకుండా బాధపడాలి. బీవర్ డెవలపర్లు స్వయంగా రక్షించటానికి వచ్చారు, వికీలో చేయవలసిన అన్ని నృత్యాలను టాంబురైన్‌తో సూచిస్తారు. చాలా బాధించే విషయం ఏమిటంటే, ఈ అన్ని స్క్వాట్‌ల తర్వాత కూడా, ప్రాజెక్ట్ దిగుమతి-ప్యాకేజీ ద్వారా కనెక్ట్ చేయబడిన 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>

ఫలితంగా I మార్పులు చేసింది SQLUtils మరియు SQLCcompletionAnalyzer తరగతుల్లోకి. ఆలోచన ఇది: ప్రోగ్రామ్ ప్రాథమిక లాజిక్‌ని ఉపయోగించి తగిన స్వీయపూర్తి సూచనలను కనుగొనలేకపోతే, అది బాహ్య xml ఫైల్‌ని ఉపయోగించి సాధ్యమైన చేరికల ఉనికిని తనిఖీ చేస్తుంది. ఈ పట్టికలను లింక్ చేయవలసిన ఫీల్డ్‌లను సూచించే పట్టికల జతలను ఫైల్ నిల్వ చేస్తుంది. eff_dttm మరియు exp_dttm రికార్డుల యొక్క సాంకేతిక చెల్లుబాటు తేదీలపై పరిమితులు మరియు లాజికల్ తొలగింపు ఫ్లాగ్ deleted_ind డిఫాల్ట్‌గా సెట్ చేయబడతాయి.

కోడ్‌లో మార్పులు చేసినప్పుడు, ప్రశ్న తలెత్తింది - మెటాడేటాతో ఫైల్‌ను ఎవరు నింపుతారు? రిపోజిటరీలో చాలా ఎంటిటీలు ఉన్నాయి, అన్ని కనెక్షన్లను మీరే నమోదు చేసుకోవడం ఖరీదైనది. ఫలితంగా, నేను ఈ పనిని నా తోటి విశ్లేషకులకు అప్పగించాలని నిర్ణయించుకున్నాను. నేను మెటాడేటా ఫైల్‌ను svnలో పోస్ట్ చేసాను, అక్కడ నుండి ప్రోగ్రామ్‌తో స్థానిక డైరెక్టరీకి చెక్అవుట్ చేయబడుతుంది. సూత్రం ఇది: రిపోజిటరీలో కొత్త ఎంటిటీ కనిపించిందా? ఒక విశ్లేషకుడు ఫైల్‌లోకి సాధ్యమైన చేరికలను నమోదు చేసి, మార్పులకు పాల్పడతారు, మిగిలిన వారు తమను తాము తనిఖీ చేసుకుంటారు మరియు పని చేసే స్వయంచాలక-పూర్తిని ఆస్వాదిస్తారు: సంఘం, జ్ఞానాన్ని సేకరించడం మరియు అన్నీ. సహోద్యోగుల కోసం ప్రోగ్రామ్‌ను ఉపయోగించడంపై వర్క్‌షాప్ నిర్వహించి, సంగమంలో ఒక కథనాన్ని రాశారు - ఇప్పుడు కంపెనీకి మరో అనుకూలమైన సాధనం ఉంది.

ఈ ఫీచర్‌పై పని చేయడం వల్ల ఓపెన్ సోర్స్ ప్రాజెక్ట్‌లతో టింకర్ చేయడానికి భయపడాల్సిన అవసరం లేదని నాకు అర్థమైంది - నియమం ప్రకారం, వారికి స్పష్టమైన నిర్మాణాలు ఉన్నాయి మరియు భాష యొక్క ప్రాథమిక జ్ఞానం కూడా ప్రయోగాలకు సరిపోతుంది. మరియు కొంత పట్టుదలతో, మీరు అసహ్యించుకునే సాధారణ కార్యకలాపాలను కూడా వదిలించుకోగలుగుతారు, కొత్త ప్రయోగాల కోసం మీ సమయాన్ని ఆదా చేసుకోవచ్చు.

మూలం: www.habr.com