🤟🏼 😳 🥩 यूनिवर्सल सोल्जर: डेटास्टेज में ग्रूवी ट्रांसफार्मर 👨🏼‍🍳 🤯 👦

आईबीएम डेटास्टेज की ईटीएल क्षमताएं डेटा एकीकरण कार्यों में उत्पन्न होने वाली आवश्यकताओं की एक विस्तृत श्रृंखला को कवर करती हैं, लेकिन, जल्दी या बाद में, सी में समानांतर रूटीन को लागू करने या जावा कक्षाओं में बाद में उपयोग किए जाने वाले जावा कक्षाओं का निर्माण करके कार्यक्षमता का विस्तार करने की आवश्यकता है। या जावा क्लाइंट। अंतर्निहित बेसिक भाषा की सीमित सुविधाएं लंबे समय से पहले पुरानी हैं और इसे गंभीर सहायता के रूप में नहीं माना जा सकता है (उदाहरण के लिए, XML संरचनाओं का उपयोग करना असंभव है, या, दूसरे उदाहरण के लिए, बेसिक का उपयोग करके एमडी 5 हैशिंग लिखने की कोशिश करें। यह संभव है, लेकिन इसे विकसित करने और डिबग करने में काफी समय लगेगा। )।
जैसा कि यह हो सकता है, मैं एक काफी लचीला उपकरण रखना चाहूंगा जो आपको डेटा स्ट्रीम के साथ काम करने की अनुमति देता है, जिसे इसके स्रोत कोड के पुन: उपयोग की आवश्यकता नहीं होती है और जिसका उपयोग डेटास्टेज क्लाइंट संपादक में किया जा सकता है। मेरे सहयोगी और करीबी दोस्त को ग्रूवी ट्रांसफार्मर विकसित करने के लिए कहा गया था। उसके बारे में और इस लेख में चर्चा की जाएगी।

क्यों ग्रोवी क्योंकि यह भाषा काफी लचीली है और इसमें जावा की सभी विशेषताएं हैं, क्योंकि यह इस भाषा के लिए एक ऐड-ऑन है, लेकिन इसके अलावा यह डेवलपर्स को निम्नलिखित लाभ प्रदान करता है:

निम्न जावा कोड के बजाय हैश (सहयोगी सरणियों) और सूचियों के लिए मूल वाक्यविन्यास
```
import java.util.* ; … HashMap<String,String> someMap=new HashMap<String,String>() ; someMap.put("Key1", "Value") ; … String valFromMap=someMap.get("Key1") ; 
```
आप निम्न Groovy कोड (java.util। * का उपयोग कर सकते हैं। पहले से ही इसमें डिफ़ॉल्ट रूप से आयात किया गया है):
```
 HashMap someMap=new HashMap(); someMap.Key1= "Value" ; … valFromMap=someMap.Key1; 
```
स्ट्रिंग की व्याख्या करना (हर कोई इसे प्रक्षेप क्यों कह रहा है?):
```
 def NumberOfItems= 10; println "Number of items=$NumberOfItems"; 
```
डायनामिक कोड निष्पादन, आप एक स्ट्रिंग चर में, एक स्ट्रीम में या संकलन के बिना फ़ाइलों में संग्रहीत कोड निष्पादित कर सकते हैं:
```
 def GroovyCode='sum=a+b; println "Sum is $sum"'; Binding binding=new Binding(); binding.setVariable("a", 10); binding.setVariable("b", 20); GroovyShell shell = new GroovyShell(binding); shell.evaluate(GroovyCode); 
```
मूल XML और JSON समर्थन:
```
 def writer=new StringWriter() ; def xmlOut=new groovy.xml.MarkupBuilder(writer) ; xmlOut.JobsInfo{ Job(name : 'ODS_MOUVEMENT_C') { precedants { precedant "ODS_ECRITURE_C" precedant "ODS_TEC_DEB" } } } println writer; 
```
इस उदाहरण को निम्न XML को प्रिंट करना चाहिए:
```
 <JobsInfo> <Job name='ODS_MOUVEMENT_C'> <precedants> <precedant>ODS_ECRITURE_C</precedant> <precedant>ODS_TEC_DEB</precedant> </precedants> </Job> </JobsInfo> 
```
यदि आप JSON उत्पन्न करना चाहते हैं, तो आपको groovy.xml को बदलने की आवश्यकता है। MarkupBuilder को groovy.json.JsonBuilder से बदलना होगा।

ग्रूवी ट्रांसफार्मर के पीछे मूल विचार यह है कि जावा ट्रांसफार्मर में ग्रूवी कोड का उपयोग किया जाए। चूंकि इस चरण में कोड सीधे लिखा जा सकता है, आप खुद तय कर सकते हैं कि क्या करना है - ग्रूवी कोड निष्पादित करें, जो फ़ाइल में संग्रहीत है, नौकरी के मापदंडों से आता है या जो आप खुद लिखेंगे।
इसलिए, हमें यह सीखने की ज़रूरत है कि जावा ट्रांसफार्मर कैसे बनाया जाए। जो लोग पहले से ही जानते हैं कि यह कैसे लागू किया जाता है, इस अनुभाग को छोड़ सकते हैं। लेकिन मैं संक्षेप में कोशिश करूंगा, क्योंकि इस हिस्से पर प्रलेखन पर्याप्त विवरण में लिखा गया है।
इसलिए, Java ट्रांसफॉर्मर बनाने के लिए, हमें एक ऐसी क्लास बनाने की ज़रूरत है जो स्टेज क्लास से विरासत में मिले:

 import com.ascentialsoftware.jds.* ; class MyJavaTransformer extends Stage{ }

और आपको तीन सबसे अधिक उपयोग किए जाने वाले तरीकों को लागू करने की आवश्यकता है: प्रारंभ (), प्रक्रिया () और समाप्त ()।
प्रारंभिक () विधि को स्ट्रीम लाइनों को संसाधित करने से पहले निष्पादित किया जाता है और इसमें उन वस्तुओं की घोषणा हो सकती है जिन्हें आप ट्रांसफार्मर के जीवन भर उपयोग करने का इरादा रखते हैं।
इनपुट स्ट्रीम के प्रत्येक लाइन के लिए प्रक्रिया () विधि निष्पादित की जाती है और इसमें आपके प्रसंस्करण का तर्क होना चाहिए।
टर्मिनेट () पद्धति को ट्रांसफार्मर के अस्तित्व के अंत में निष्पादित किया जाता है और इसमें अस्थायी वस्तुओं को हटाने के लिए क्रियाएं हो सकती हैं (हां मुझे पता है कि जावा में कोई विध्वंसक नहीं हैं, मेरा मतलब है कि आपके द्वारा उपयोग किया गया कोई कचरा: फाइलें, टेबल, आप कभी नहीं जानते हैं)।
समानांतर ट्रांसफार्मर मोड के लिए ध्यान दें: DataStage प्रत्येक नोड के लिए एक अलग जावा मशीन लॉन्च करता है। दूसरे शब्दों में, यदि आपके पास चार नोड हैं, तो डेटास्टेज चार जेवीएम लॉन्च करेगा। चूंकि वर्चुअल मशीनें अलग-थलग हैं, इसलिए आपके पास उनमें से प्रत्येक में चल रहे थ्रेड्स के बीच डेटा के आदान-प्रदान के लिए स्वीकार्य तरीके नहीं हैं।

अब हम अपने जावा ट्रांसफार्मर के लिए एक खाका तैयार करने के लिए तैयार हैं:

 import com.ascentialsoftware.jds.*; public class MyJavaTransformer extends Stage { public void initialize() { trace("Init"); } public void terminate() { trace("Terminate"); } public int process() { return 0; } }

ट्रांसफार्मर में प्रवेश करने और छोड़ने वाली रेखाओं को पढ़ने के लिए, आप पंक्ति वस्तु और दो तरीकों का उपयोग कर सकते हैं: readRow () इनपुट स्ट्रीम और राइटर () लिखने के आउटपुट तक पहुंचने के लिए।
पंक्ति वस्तु प्रत्येक कॉलम के मेटाडेटा को पुनः प्राप्त करने की क्षमता भी प्रदान करती है और आपको इन कॉलमों के मूल्यों को प्राप्त करने की अनुमति देती है। निम्न उदाहरण प्रदर्शित करता है कि आप सभी स्तंभों के मानों को कैसे बदल सकते हैं, जो कि वर्कर के प्रकार "जावा से हैलो", अन्य सभी स्तंभों को "बदलाव" के बिना "बदलाव" के साथ बदल सकते हैं:

 public int process() { Row inputRow=readRow() ; if (inputRow == null) //     return OUTPUT_STATUS_END_OF_DATA; Row outputRow=createOutputRow(); for (int i=0;i<inputRow.getColumnCount();i++) { Object column=inputRow.getValueAsSQLTyped(i); if (column instanceof java.lang.String) outputRow.setValueAsSQLTyped(i, “Hello from Java”); else outputRow.setValueAsSQLTyped(i, column); } writeRow(outputRow); }

नोट : ट्रांसफॉर्मर क्लास को संकलित करने के लिए, tr4j.jar लाइब्रेरी को क्लास पथ या अपने IDE में आयात करना सुनिश्चित करें।
अब हम अपने ग्रूवी ट्रांसफार्मर के लिए आवश्यकताओं को तैयार कर सकते हैं।

Groovy Transformer एक JavaTransformer है जो मक्खी पर Groovy कोड संकलित करता है। यह नियमित संचालन को सुगम बनाने के लिए सिंटैक्टिक शुगर को जोड़ता है जिसे स्टेज क्लास के साथ काम करते समय किया जाता है।

तो, हमारे ट्रांसफार्मर चाहिए:

जावा ट्रांसफॉर्मर चरण के स्टेज-> गुण टैब से ग्रूवी कोड प्राप्त करें;
इनपुट और आउटपुट धाराओं के मेटाडेटा तक पहुंच की अनुमति दें;
कॉलम डेटा को उनके नाम (कॉलम नंबर के बजाय) से हेरफेर करने की अनुमति दें।

इन आवश्यकताओं के अनुसार, ग्रूवी ट्रांसफार्मर बनाया गया था, जिसे आप यहां डाउनलोड कर सकते हैं: http://geckelberryfinn.ru/fr/GroovyTransformer.html । (सावधानी! यह जावा ट्रांसफॉर्मर ग्रूवी = में भी लिखा गया है), अपघटन के साथ समस्याएं होंगी)।

ग्रूवी ट्रांसफार्मर निम्नलिखित वस्तुओं को पूर्वनिर्धारित करता है:

वस्तु	विवरण	उदाहरण
GTransformer	वस्तु। इस स्टेज क्लास से लिंक करें। इस वर्ग के सभी तरीकों और विशेषताओं को समाहित करता है।	GTransformer.createOutputRow ()
OutputMatching	HashMap। कॉलम के नाम और उनके सूचक शामिल हैं।	OutputMatching.get (k); OutputMatching.ID; OutputMatching.LIBL;
मेटा डेटा	HashMap। इनपुट स्ट्रीम के कार्यप्रणाली कॉलम के बारे में जानकारी शामिल है।	MetaData.ID.Description; MetaData.ID.Derivation; MetaData.ID.SQLType: MetaData.ID.DataElementName;
OutputMetaData	HashMap। विधिपूर्वक आउटपुट स्ट्रीम पर जानकारी समाहित करता है	OutputMetaData.ID.Description; OutputMetaData.ID.Derivation; OutputMetaData.ID.SQLType: OutputMetaData.ID.DataElementName;
InputColumns	HashMap। सभी इनपुट स्ट्रीम कॉलम शामिल हैं	InputColumns.ID; InputColumns.LIBL;
OutputRows	सूची <, हशपप>। आउटपुट स्ट्रीम लाइनों की सूची। आप इस ऑब्जेक्ट का उपयोग तब कर सकते हैं जब आने वाली लाइनों की संख्या आने वाली लाइनों की संख्या से अधिक हो।	HashMap curRow = नया HashMap (); outputRows [0] = curRow; outputRows [0] .ID = 0; outputRows [0] .LIBL = "पहला आइटम";

इस प्रकार, आउटपुट स्ट्रीम बनाने के दो तरीके हैं:

आउटपुटरोज़ की सूची भरें;
CreateOutputRow () विधि को कॉल करें, और उसके बाद GTransformer ऑब्जेक्ट को लिखें।

किस विधि का उपयोग करना है यह विशिष्ट स्थिति पर निर्भर करता है।

अपनी परियोजनाओं में ग्रूवी ट्रांसफार्मर का उपयोग शुरू करने के लिए, जावा ट्रांसफार्मर चरण के गुणों को आबाद करना अच्छा होगा:

ट्रांसफार्मर वर्ग का नाम: groovytransformer.GroovyTransformer
उपयोगकर्ता का क्लासपाथ: /पथ / //jar/GroovyTransformer.jar

नीचे मैं ग्रूवी ट्रांसफार्मर के उपयोग के कुछ उदाहरण दूंगा:

जेडीबीसी स्रोत से आसान डेटा पुनर्प्राप्ति।
इस उदाहरण में, हम Oracle के DBMS के रूप में उपयोग करके ODS.AXE_LOCAL तालिका से डेटा निकालेंगे, हालाँकि इसके लिए एक अलग चरण है। लेकिन, वास्तव में, इस कोड का उपयोग उन मामलों में किया जा सकता है जब "विदेशी डेटा स्रोतों" से डेटा प्राप्त करना आवश्यक होता है (इंटरबेस, फॉक्सप्रो, वेक्टरवाइज, डर्बी, SQLite, H2 आदि)।
यह ग्रूवी कोड काफी सार्वभौमिक है, क्योंकि यह एसक्यूएल प्रश्नों को छोड़कर विशिष्ट जानकारी का उपयोग नहीं करता है। दूसरे शब्दों में, इसका उपयोग किसी भी मामले में किया जा सकता है।
इस उदाहरण को चलाने के लिए, ट्रांसफार्मर के "आउटपुट" टैब में केस-संवेदी नामों वाले कॉलम की सूची जोड़ना न भूलें।
```
 sql = Sql.newInstance( 'jdbc:oracle:thin:@oraclehost:1533/nomdebdd', 'user', 'password', 'oracle.jdbc.OracleDriver' ); sql.eachRow('select id, LIBL_AXE_CENTRAL, SYS_CREATED_DAT as DAT_DEB_VALID from ODS.ODS_AXE_CENTRAL') { it -> GRow=GTransformer.createOutputRow(); i=0; it.toRowResult().each{k,v-> i++; if (v instanceof java.sql.Date) GRow.setValueAsSQLTyped(OutputMatching.get(k),it.getTimestamp(i)); else GRow.setValueAsSQLTyped(OutputMatching.get(k),v) ; } GTransformer.writeRow(GRow); } 
```
नियमित अभिव्यक्ति का उपयोग करना।
इस उदाहरण में, हम अनुबंध (इसकी संख्या और तारीख) के बारे में फार्म की लाइनों से जानकारी निकालने का प्रयास करेंगे:

"अनुबंध FU-1009 दिनांक 10/01/1960"
"सेवा अनुबंध FU-1019 10/01/1961 के लिए"
"10/01/1962 से कॉन-टी नंबर FU-1001"

और हमें आउटपुट पर दो कॉलम प्राप्त करने की सलाह दी जाती है: अनुबंध संख्या और उसके समापन की तारीख।
इस मामले में, आप निम्नलिखित नियमित अभिव्यक्तियों का उपयोग कर सकते हैं:
- अनुबंध संख्या के लिए: [AZ] + (- [AZ]) + (- [0-9] +)
- इसकी तिथि के लिए: [0-3]? [0-9] (/ | \\।) [0-1]? [0-9]? [0-9] (/ | \\।) (19 | 20)? [0-9] ] {२}
फिर इस उदाहरण के लिए, ग्रूवी कोड इस तरह हो सकता है (ध्यान दें कि आउटपुट स्ट्रीम उत्पन्न करने का एक और तरीका उपयोग किया जाता है)
```
 String StrIn=InputColumns.contrat contRegExp="[AZ]+(-[AZ])+(-[0-9]+)" datRegExp="[0-3]?[0-9](/|\\.)[0-1]?[0-9](/|\\.)(19|20)?[0-9]{2}" def matchRegEx(str, regExp) { matcher=(str=~regExp); if (matcher.getCount()!=0) return matcher[0][0]; else return null; } def cont=matchRegEx(StrIn, contRegExp); def dat =matchRegEx(StrIn, datRegExp); HashMap curRow=new HashMap(); OutputRows[0]=curRow; OutputRows[0].contrat=StrIn; OutputRows[0].numero=cont; OutputRows[0].date=dat; 
```

कुछ उपयोगी लिंक:

ग्रूवी हैंडबुक: http://groovy.codehaus.org/Documentation
जावा ट्रांसफॉर्मर उदाहरण: http://www.ibm.com/developerworks/data/library/techarticle/dm-1106etljob/index.html

यूनिवर्सल सोल्जर: डेटास्टेज में ग्रूवी ट्रांसफार्मर

More articles: