એક જ વસ્તુ કરવાનું કેવી રીતે બંધ કરવું

શું તમને નિયમિત કામગીરીનું વારંવાર પુનરાવર્તન કરવાનું ગમે છે? તેથી હું નથી. પરંતુ દરેક વખતે SQL ક્લાયંટમાં જ્યારે Rostelecom સ્ટોરેજ સાથે કામ કરતા હતા, ત્યારે મારે ટેબલ વચ્ચેના તમામ જોડા મેન્યુઅલી રજીસ્ટર કરવા પડતા હતા. અને આ એ હકીકત હોવા છતાં કે 90% કેસોમાં કોષ્ટકોમાં જોડાવા માટેના ક્ષેત્રો અને શરતો ક્વેરીથી ક્વેરી એકસરખાં છે! એવું લાગે છે કે કોઈપણ એસક્યુએલ ક્લાયંટમાં સ્વતઃ-પૂર્ણતા કાર્યો હોય છે, પરંતુ સ્ટોરેજ માટે તે હંમેશા કામ કરતું નથી: પ્રદર્શન સુધારવા માટે તેઓ ભાગ્યે જ અનન્ય અવરોધ અને વિદેશી કીનો સમાવેશ કરે છે, અને આ વિના પ્રોગ્રામ જાણશે નહીં કે એન્ટિટી દરેક સાથે કેવી રીતે સંબંધિત છે. અન્ય અને તે તમારા માટે શું કરી શકે છે.

ઇનકાર, ગુસ્સો, સોદાબાજી, ઉદાસીનતા અને સ્વીકૃતિની નજીક આવવાથી પસાર થયા પછી, મેં નક્કી કર્યું - શા માટે બ્લેકજેક સાથે સ્વતઃભરણનો અમલ કરવાનો પ્રયાસ ન કરવો અને તે યોગ્ય રીતે કરવું? હું dbeaver ક્લાયંટનો ઉપયોગ કરું છું, જે java માં લખાયેલ છે, તેની પાસે ઓપન સોર્સ કોમ્યુનિટી વર્ઝન છે. એક સરળ યોજના પરિપક્વ થઈ છે:

1. સ્ત્રોત કોડમાં વર્ગો શોધો જે સ્વતઃપૂર્ણ માટે જવાબદાર છે
2. તેમને બાહ્ય મેટાડેટા સાથે કામ કરવા માટે રીડાયરેક્ટ કરો અને ત્યાંથી જોડાવાની માહિતી ખેંચો
3. ??????
4. નફાની

મેં પહેલો મુદ્દો ખૂબ જ ઝડપથી શોધી કાઢ્યો - મને બગ ટ્રેકરમાં ઑટોફિલને સમાયોજિત કરવા માટે વિનંતી મળી અને સંબંધિત પ્રતિબદ્ધ SQLCompletionAnalyser વર્ગ શોધ્યો. મેં કોડ જોયો અને તે જ મને જોઈએ છે. જે બાકી છે તે ફરીથી લખવાનું છે જેથી બધું કાર્ય કરે. મેં એક મફત સાંજની રાહ જોઈ અને અમલીકરણ દ્વારા વિચારવાનું શરૂ કર્યું. મેં json માં ટેબલ લિંક નિયમો (મેટાડેટા) લખવાનું નક્કી કર્યું. મને આ ફોર્મેટ સાથે કામ કરવાનો કોઈ વ્યવહારુ અનુભવ નહોતો અને વર્તમાન કાર્યને આ ભૂલને સુધારવાની તક તરીકે જોવામાં આવ્યું હતું.

json સાથે કામ કરવા માટે મેં લાઇબ્રેરીનો ઉપયોગ કરવાનું નક્કી કર્યું json-સરળ Google માંથી. અહીંથી આશ્ચર્યની શરૂઆત થઈ. તે બહાર આવ્યું તેમ, dbeaver, સાચી એપ્લિકેશન તરીકે, OSGi ફ્રેમવર્કનો ઉપયોગ કરીને Eclipse પ્લેટફોર્મ પર લખવામાં આવ્યું હતું. અનુભવી વિકાસકર્તાઓ માટે, આ વસ્તુ નિર્ભરતાને સંચાલિત કરવાનું અનુકૂળ બનાવે છે, પરંતુ મારા માટે તે વધુ શ્યામ જાદુ જેવું હતું, જેના માટે હું સ્પષ્ટપણે તૈયાર નહોતો: હંમેશની જેમ, હું હેડરમાં json-સિમ્પલ લાઇબ્રેરીમાંથી મને જોઈતા વર્ગો આયાત કરું છું. સંપાદિત વર્ગ, તેને pom. xml માં સ્પષ્ટ કરો, જે પછી પ્રોજેક્ટ સ્પષ્ટપણે સામાન્ય રીતે એસેમ્બલ થવાનો ઇનકાર કરે છે અને ભૂલો સાથે ક્રેશ થાય છે.

અંતે, મેં બિલ્ડ ભૂલોને ઠીક કરવામાં વ્યવસ્થાપિત કરી: મેં લાઇબ્રેરીને pom.xml માં નહીં, પરંતુ manifest.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>

પરિણામે આઇ ફેરફારો કર્યા SQLUtils અને SQLCompletionAnalyser વર્ગોમાં. વિચાર આ છે: જો પ્રોગ્રામ મૂળભૂત તર્કનો ઉપયોગ કરીને યોગ્ય સ્વતઃપૂર્ણ સૂચનો શોધવામાં અસમર્થ હતો, તો તે બાહ્ય xml ફાઇલનો ઉપયોગ કરીને સંભવિત જોડાણોની હાજરી માટે તપાસે છે. ફાઇલ પોતે કોષ્ટકોની જોડીને સંગ્રહિત કરે છે જે ક્ષેત્રો દર્શાવે છે કે જેના દ્વારા આ કોષ્ટકોને લિંક કરવાની જરૂર છે. રેકોર્ડ્સ eff_dttm અને exp_dttm અને લોજિકલ ડિલીશન ફ્લેગ deleted_ind ની તકનીકી માન્યતા તારીખો પરના નિયંત્રણો ડિફૉલ્ટ રૂપે સેટ છે.

જ્યારે કોડમાં ફેરફારો કરવામાં આવ્યા હતા, ત્યારે પ્રશ્ન ઊભો થયો હતો - મેટાડેટા સાથે ફાઇલ કોણ ભરશે? રિપોઝીટરીમાં ઘણી બધી એન્ટિટી છે, બધા કનેક્શન્સ જાતે રજીસ્ટર કરવા ખર્ચાળ છે. પરિણામે, મેં આ કાર્ય મારા સાથી વિશ્લેષકોને સોંપવાનું નક્કી કર્યું. મેં મેટાડેટા ફાઇલને svn માં પોસ્ટ કરી છે, જ્યાંથી પ્રોગ્રામ સાથે સ્થાનિક ડિરેક્ટરીમાં ચેકઆઉટ કરવામાં આવે છે. સિદ્ધાંત આ છે: શું રીપોઝીટરીમાં નવી એન્ટિટી દેખાઈ છે? એક વિશ્લેષક ફાઇલમાં સંભવિત જોડાય છે, ફેરફારો કરે છે, બાકીના પોતાને તપાસે છે અને કાર્યકારી સ્વતઃ-સંપૂર્ણતાનો આનંદ માણે છે: સમુદાય, જ્ઞાનનો સંચય અને તે બધું. સહકર્મીઓ માટે પ્રોગ્રામનો ઉપયોગ કરવા પર એક વર્કશોપનું આયોજન કર્યું, કન્ફ્લુઅન્સમાં એક લેખ લખ્યો - હવે કંપની પાસે એક વધુ અનુકૂળ સાધન છે.

આ સુવિધા પર કામ કરવાથી મને સમજાયું કે ઓપન સોર્સ પ્રોજેક્ટ્સ સાથે ટિંકર કરવામાં ડરવાની જરૂર નથી - એક નિયમ તરીકે, તેમની પાસે સ્પષ્ટ આર્કિટેક્ચર છે, અને ભાષાનું મૂળભૂત જ્ઞાન પણ પ્રયોગો માટે પૂરતું હશે. અને ચોક્કસ દ્રઢતા સાથે, તમે નવા પ્રયોગો માટે તમારો સમય બચાવીને, ધિક્કારપાત્ર નિયમિત કામગીરીમાંથી પણ છુટકારો મેળવી શકશો.

સોર્સ: www.habr.com