ഒരേ കാര്യം ചെയ്യുന്നത് എങ്ങനെ നിർത്താം

പതിവ് പ്രവർത്തനങ്ങൾ വീണ്ടും വീണ്ടും ആവർത്തിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുണ്ടോ? അതുകൊണ്ട് ഞാനില്ല. എന്നാൽ ഓരോ തവണയും SQL ക്ലയന്റിൽ Rostelecom സ്റ്റോറേജിൽ പ്രവർത്തിക്കുമ്പോൾ, പട്ടികകൾക്കിടയിലുള്ള എല്ലാ ജോയിംഗുകളും സ്വമേധയാ രജിസ്റ്റർ ചെയ്യേണ്ടിവന്നു. 90% കേസുകളിലും ടേബിളുകളിൽ ചേരുന്നതിനുള്ള ഫീൽഡുകളും വ്യവസ്ഥകളും അഭ്യർത്ഥന മുതൽ അഭ്യർത്ഥന വരെ പൊരുത്തപ്പെടുന്നു എന്ന വസ്തുത ഉണ്ടായിരുന്നിട്ടും ഇത്! ഏതൊരു SQL ക്ലയന്റിനും സ്വയമേവ പൂർത്തീകരണ പ്രവർത്തനങ്ങൾ ഉണ്ടെന്ന് തോന്നുന്നു, പക്ഷേ സ്റ്റോറേജുകൾക്ക് ഇത് എല്ലായ്പ്പോഴും പ്രവർത്തിക്കില്ല: പ്രകടനം മെച്ചപ്പെടുത്തുന്നതിനായി അവ അപൂർവ്വമായി അദ്വിതീയ നിയന്ത്രണവും വിദേശ കീയും ഉൾക്കൊള്ളുന്നു, കൂടാതെ ഇത് കൂടാതെ ഓരോ എന്റിറ്റികളും എങ്ങനെ ബന്ധപ്പെട്ടിരിക്കുന്നുവെന്ന് പ്രോഗ്രാമിന് അറിയില്ല. മറ്റുള്ളവയും നിങ്ങൾ ഓഫർ ചെയ്യുന്നതിന് അതിന് എന്ത് ചെയ്യാൻ കഴിയും.

നിഷേധം, കോപം, വിലപേശൽ, വിഷാദം, സ്വീകാര്യതയെ സമീപിക്കുക എന്നിവയിലൂടെ കടന്നുപോയി, ഞാൻ തീരുമാനിച്ചു - ബ്ലാക്ക് ജാക്ക് ഉപയോഗിച്ച് സ്വയം പൂരിപ്പിക്കൽ നടപ്പിലാക്കാനും ശരിയായ രീതിയിൽ അത് ചെയ്യാനും എന്തുകൊണ്ട് ശ്രമിക്കരുത്? ഞാൻ ജാവയിൽ എഴുതിയ dbeaver ക്ലയന്റ് ഉപയോഗിക്കുന്നു, അതിന് ഒരു ഓപ്പൺ സോഴ്‌സ് കമ്മ്യൂണിറ്റി പതിപ്പുണ്ട്. ഒരു ലളിതമായ പ്ലാൻ പക്വത പ്രാപിച്ചു:

1. സ്വയം പൂർത്തീകരണത്തിന് ഉത്തരവാദികളായ സോഴ്സ് കോഡിലെ ക്ലാസുകൾ കണ്ടെത്തുക
2. ബാഹ്യ മെറ്റാഡാറ്റയ്‌ക്കൊപ്പം പ്രവർത്തിക്കാൻ അവരെ റീഡയറക്‌ട് ചെയ്യുകയും അവിടെ നിന്ന് ചേരുന്നതിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ പിൻവലിക്കുകയും ചെയ്യുക
3. മൂടുപടം
4. ലാഭം

ആദ്യ പോയിന്റ് ഞാൻ വളരെ വേഗത്തിൽ കണ്ടെത്തി - ഓട്ടോഫിൽ ക്രമീകരിക്കാനുള്ള ബഗ് ട്രാക്കറിൽ ഒരു അഭ്യർത്ഥന ഞാൻ കണ്ടെത്തി പ്രതിബദ്ധത SQLCcompletionAnalyzer ക്ലാസ് കണ്ടെത്തി. ഞാൻ കോഡ് നോക്കി, അതാണ് എനിക്ക് വേണ്ടത്. എല്ലാം പ്രവർത്തിക്കുന്നതിന് അത് വീണ്ടും എഴുതുക മാത്രമാണ് അവശേഷിക്കുന്നത്. ഞാൻ ഒരു സൌജന്യ സായാഹ്നത്തിനായി കാത്തിരുന്നു, നടപ്പാക്കലിനെക്കുറിച്ച് ചിന്തിക്കാൻ തുടങ്ങി. ഞാൻ json-ൽ പട്ടിക ലിങ്ക് നിയമങ്ങൾ (മെറ്റാഡാറ്റ) എഴുതാൻ തീരുമാനിച്ചു. ഈ ഫോർമാറ്റിൽ പ്രവർത്തിച്ച എനിക്ക് പ്രായോഗിക പരിചയം ഇല്ലായിരുന്നു, ഈ ഒഴിവാക്കൽ തിരുത്താനുള്ള അവസരമായാണ് ഇപ്പോഴത്തെ ചുമതല കണ്ടത്.

json-നൊപ്പം പ്രവർത്തിക്കാൻ ഞാൻ ലൈബ്രറി ഉപയോഗിക്കാൻ തീരുമാനിച്ചു json-ലളിതമായ Google-ൽ നിന്ന്. ഇവിടെയാണ് ആശ്ചര്യങ്ങളുടെ തുടക്കം. അത് മാറിയതുപോലെ, dbeaver, ഒരു യഥാർത്ഥ ആപ്ലിക്കേഷൻ എന്ന നിലയിൽ, OSGi ഫ്രെയിംവർക്ക് ഉപയോഗിച്ച് എക്ലിപ്സ് പ്ലാറ്റ്ഫോമിൽ എഴുതിയിരിക്കുന്നു. പരിചയസമ്പന്നരായ ഡെവലപ്പർമാർക്ക്, ഈ കാര്യം ഡിപൻഡൻസികൾ കൈകാര്യം ചെയ്യുന്നത് സൗകര്യപ്രദമാക്കുന്നു, പക്ഷേ എന്നെ സംബന്ധിച്ചിടത്തോളം ഇത് ഡാർക്ക് മാജിക് പോലെയായിരുന്നു, അതിന് ഞാൻ വ്യക്തമായി തയ്യാറല്ലായിരുന്നു: പതിവുപോലെ, ഹെഡറിലെ json-സിമ്പിൾ ലൈബ്രറിയിൽ നിന്ന് എനിക്ക് ആവശ്യമായ ക്ലാസുകൾ ഞാൻ ഇറക്കുമതി ചെയ്യുന്നു. എഡിറ്റ് ചെയ്‌ത ക്ലാസ്, അത് പോം. xml-ൽ വ്യക്തമാക്കുക, അതിനുശേഷം പ്രോജക്റ്റ് സാധാരണയായി കൂട്ടിച്ചേർക്കാൻ വിസമ്മതിക്കുകയും പിശകുകളാൽ ക്രാഷ് ചെയ്യുകയും ചെയ്യുന്നു.

അവസാനം, ബിൽഡ് പിശകുകൾ പരിഹരിക്കാൻ എനിക്ക് കഴിഞ്ഞു: ഞാൻ ലൈബ്രറി രജിസ്റ്റർ ചെയ്തത് pom.xml-ൽ അല്ല, OSGI ആവശ്യപ്പെടുന്നതുപോലെ, ഇംപോർട്ട്-പാക്കേജ് എന്ന് വ്യക്തമാക്കുമ്പോൾ, മാനിഫെസ്റ്റ്.എംഎഫ് മാനിഫെസ്റ്റിലാണ്. ഏറ്റവും മനോഹരമായ പരിഹാരമല്ല, പക്ഷേ അത് പ്രവർത്തിക്കുന്നു. അപ്പോൾ അടുത്ത ആശ്ചര്യം പ്രത്യക്ഷപ്പെട്ടു. നിങ്ങൾ ഇന്റലിജ് ഐഡിയയിലാണ് വികസിക്കുന്നതെങ്കിൽ, എക്ലിപ്സ് പ്ലാറ്റ്‌ഫോമിനെ അടിസ്ഥാനമാക്കി നിങ്ങൾക്ക് പോയി നിങ്ങളുടെ പ്രോജക്റ്റ് ഡീബഗ്ഗിംഗ് ആരംഭിക്കാൻ കഴിയില്ല: ഒരു അനുഭവപരിചയമില്ലാത്ത ഡെവലപ്പർ അന്വേഷണം പൂർത്തിയാക്കാതെ തന്നെ ഒരു അനലിസ്റ്റിൽ കുറയാതെ കഷ്ടപ്പെടണം. ബീവർ ഡെവലപ്പർമാർ തന്നെ രക്ഷാപ്രവർത്തനത്തിന് എത്തി, ചെയ്യേണ്ടത് ഒരു തംബുരു ഉപയോഗിച്ചുള്ള എല്ലാ നൃത്തങ്ങളും വിക്കിയിൽ സൂചിപ്പിക്കുന്നു. ഏറ്റവും അരോചകമായ കാര്യം, ഈ സ്ക്വാറ്റുകൾക്കെല്ലാം ശേഷവും, ഇറക്കുമതി-പാക്കേജ് വഴി ബന്ധിപ്പിച്ചിരിക്കുന്ന 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 എന്നീ റെക്കോർഡുകളുടെ സാങ്കേതിക സാധുതയുള്ള തീയതികളിലെ നിയന്ത്രണങ്ങളും ഡിഫോൾട്ടായി സജ്ജീകരിച്ചിരിക്കുന്നു.

കോഡിൽ മാറ്റങ്ങൾ വരുത്തിയപ്പോൾ, ചോദ്യം ഉയർന്നു - ആരാണ് മെറ്റാഡാറ്റ ഉപയോഗിച്ച് ഫയൽ പൂരിപ്പിക്കുക? റിപ്പോസിറ്ററിയിൽ ധാരാളം എന്റിറ്റികളുണ്ട്, എല്ലാ കണക്ഷനുകളും സ്വയം രജിസ്റ്റർ ചെയ്യുന്നത് ചെലവേറിയതാണ്. തൽഫലമായി, ഈ ചുമതല എന്റെ സഹ വിശകലന വിദഗ്ധർക്ക് നൽകാൻ ഞാൻ തീരുമാനിച്ചു. ഞാൻ മെറ്റാഡാറ്റ ഫയൽ svn-ൽ പോസ്റ്റ് ചെയ്തു, അവിടെ നിന്ന് പ്രോഗ്രാമിനൊപ്പം ലോക്കൽ ഡയറക്‌ടറിയിലേക്ക് ഒരു ചെക്ക്ഔട്ട് നടക്കുന്നു. തത്വം ഇതാണ്: റിപ്പോസിറ്ററിയിൽ ഒരു പുതിയ എന്റിറ്റി പ്രത്യക്ഷപ്പെട്ടിട്ടുണ്ടോ? ഒരു വിശകലന വിദഗ്ധൻ ഫയലിലേക്ക് സാധ്യമായ ജോയിൻ ചെയ്യുന്നു, മാറ്റങ്ങൾ വരുത്തുന്നു, ബാക്കിയുള്ളവർ സ്വയം പരിശോധിച്ച് സ്വയം പൂർത്തീകരണം ആസ്വദിക്കുന്നു: സമൂഹം, അറിവിന്റെ ശേഖരണം എന്നിവയും എല്ലാം. സഹപ്രവർത്തകർക്കായി പ്രോഗ്രാം ഉപയോഗിക്കുന്നതിനെക്കുറിച്ച് ഒരു വർക്ക്ഷോപ്പ് നടത്തി, കൺഫ്ലൂയൻസിൽ ഒരു ലേഖനം എഴുതി - ഇപ്പോൾ കമ്പനിക്ക് സൗകര്യപ്രദമായ ഒരു ഉപകരണം കൂടിയുണ്ട്.

ഈ സവിശേഷതയിൽ പ്രവർത്തിക്കുന്നത്, ഓപ്പൺ സോഴ്‌സ് പ്രോജക്‌ടുകളുമായി ടിങ്കർ ചെയ്യാൻ ഭയപ്പെടേണ്ടതില്ലെന്ന ധാരണ എനിക്ക് നൽകി - ചട്ടം പോലെ, അവർക്ക് വ്യക്തമായ വാസ്തുവിദ്യയുണ്ട്, കൂടാതെ ഭാഷയെക്കുറിച്ചുള്ള അടിസ്ഥാന അറിവ് പോലും പരീക്ഷണങ്ങൾക്ക് മതിയാകും. ഒരു നിശ്ചിത അളവിലുള്ള സ്ഥിരോത്സാഹത്തോടെ, നിങ്ങൾക്ക് വെറുക്കപ്പെട്ട പതിവ് പ്രവർത്തനങ്ങളിൽ നിന്ന് മുക്തി നേടാനും പുതിയ പരീക്ഷണങ്ങൾക്കായി സ്വയം സമയം ലാഭിക്കാനും കഴിയും.

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