😿 👩‍🌾 👩🏿‍🏭 छत्ता बनाम सुअर। मुझे ईटीएल के लिए क्या चाहिए? ✝️ 👩🏿‍🚒 📅

एक दिन खोना बेहतर है, लेकिन फिर पांच मिनट में उड़ान भरें

हाय साथियों!

मैं आपके साथ अपने विचारों को साझा करना चाहता हूं कि Hadoop इकोसिस्टम में Hive और Pig फ्रेमवर्क कैसे भिन्न होते हैं। वास्तव में, ये दो समान उत्पाद हैं, जिनमें से एक ही लक्ष्य है - MapReduce के संपूर्ण तकनीकी कार्यान्वयन को लेने के लिए, एक और अधिक सार स्तर पर डेटा प्रसंस्करण प्रक्रिया का वर्णन करने का अवसर प्रदान करना। इस लेख में, हम देखेंगे कि नमूने इन दो प्रणालियों में कैसे दिखते हैं, और यह समझने की कोशिश करते हैं कि किन मामलों में एक या दूसरे समाधान का उपयोग किया जाना चाहिए।

मधुमुखी का छत्ता

तो, चलो हाइव के साथ शुरू करते हैं। इसकी मुख्य विशेषता SQL-जैसी HQL क्वेरी भाषा है। यह आपको डेटा के साथ काम करने की अनुमति देता है जो हमारे लिए परिचित है, जैसे कि हम एक नियमित रिलेशनल डेटाबेस के साथ काम कर रहे थे। स्क्रिप्ट को कंसोल के माध्यम से या कमांड लाइन का उपयोग करके चलाया जा सकता है।

छत्ता है:

SQL- जैसे HQL
इंटरएक्टिव कंसोल
अंतर्निर्मित कार्य
उपयोगकर्ता सुविधा समर्थन (UDF)
डेटा एक तालिका की तरह है

छत्ता काम कर सकता है:

पाठ फ़ाइलों के साथ (आप एक सीमांकक निर्दिष्ट कर सकते हैं)
संपीड़ित पाठ फ़ाइलों के साथ (Gzip, Bzip)
सरणियों, शब्दकोशों, यूनियनों (संघ) के साथ
संग्रह, दिनांक, तार, JSON: के साथ काम करने के लिए अंतर्निहित कार्यों की एक बड़ी संख्या है
गणितीय कार्यों के साथ (गोलाई, लघुगणक, मूल, त्रिकोणमिति)
एकत्रीकरण कार्यों के साथ (योग, न्यूनतम, अधिकतम, औसत ...)
यदि उपरोक्त सभी पर्याप्त नहीं थे, तो आप कस्टम फ़ंक्शंस, साथ ही मैपर और रीड्यूसर (अजगर, जावा) का उपयोग कर सकते हैं

एक सरल उदाहरण:

--  . (  ) CREATE EXTERNAL TABLE win_bids_log ( date_field string, request_id string, user_ssp_id string, dsp_id string, win_price int ) ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t' LOCATION 'hdfs://inpit/bid-logs'; CREATE EXTERNAL TABLE win_bids_by_dsp ( dsp_id string, win_bids_cout int, win_price int ) ROW FORMAT DELIMITED FIELDS TERMINATED BY '\t' STORED AS TEXTFILE LOCATION ''hdfs://output/win-bids-by-dsp''; INSERT OVERWRITE TABLE win_bids_by_dsp SELECT dsp_id, COUNT(dsp_id), SUM(win_price) FROM win_bids_log GROUP BY dsp_id;

जैसा कि आप देख सकते हैं, सब कुछ काफी सरल और स्पष्ट है। एक परिचित भाषा में प्रश्न लिखने के लिए बहुत अच्छा है। लेकिन यह खुशी तब तक जारी रहती है जब तक आपको अधिक जटिल अनुरोधों से निपटना नहीं पड़ता।

एक उदाहरण अधिक जटिल है:

 INSERT OVERWRITE TABLE movieapp_log_stage SELECT * FROM ( SELECT custid, movieid, CASE WHEN genreid > 0 THEN genreid ELSE -1 END genreid, time, CAST((CASE recommended WHEN 'Y' THEN 1 ELSE 0 END) AS INT) recommended, activity, CAST(null AS INT) rating, price FROM movieapp_log_avro WHERE activity IN (2,4,5,11) UNION ALL SELECT m1.custid, m1.movieid, CASE WHEN m1.genreid > 0 THEN m1.genreid ELSE -1 END genreid, m1.time, CAST((CASE m1.recommended WHEN 'Y' THEN 1 ELSE 0 END) AS INT) recommended, m1.activity, m1.rating, CAST(null as float) price FROM movieapp_log_avro m1 JOIN ( SELECT custid,movieid, CASE WHEN genreid > 0 THEN genreid ELSE -1 END genreid,MAX(time) max_time, activity FROM movieapp_log_avro GROUP BY custid, movieid, genreid, activity ) m2 ON ( m1.custid = m2.custid AND m1.movieid = m2.movieid AND m1.genreid = m2.genreid AND m1.time = m2.max_time AND m1.activity = 1 AND m2.activity = 1 ) ) union_result;

बेशक आप इसका पता लगा सकते हैं, लेकिन फिर भी यह पहचानने लायक है कि इस मामले में निश्चित रूप से आदेश की कमी है। यह सब अलमारियों पर रखो, लेकिन टिप्पणियों के साथ। है ना?

कुल:

छत्ता पेशेवरों:

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

छत्ता विपक्ष:

HQL प्रतिमान में सब कुछ नहीं डाला जा सकता है
यह सरल नमूनों के साथ अच्छी तरह से फिट बैठता है। लेकिन बढ़ती जटिलता के साथ, उन्हें समझना कठिन और कठिन हो जाता है। खासकर यदि आपने नमूना नहीं लिखा है

सूअर

अब बात करते हैं सुअर की। यह प्रक्रियात्मक भाषा पिग लैटिन पर आधारित है। इसका पता लगाने के लिए आपको कुछ समय बिताने की जरूरत है।

चलिए इसका पता लगाते हैं और हाइव से अंतर का पता लगाते हैं

सुअर है:

सुअर लैटिन
इंटरएक्टिव कंसोल
अंतर्निर्मित कार्य
उपयोगकर्ता सुविधा समर्थन (UDF)
डेटा - संरचनाओं के रूप में (टपल, बैग)

सुअर काम कर सकता है:

पाठ फ़ाइलों के साथ (आप एक सीमांकक निर्दिष्ट कर सकते हैं)
संपीड़ित पाठ फ़ाइलों के साथ (Gzip, Bzip)
सरणियों, शब्दकोशों, यूनियनों (संघ) के साथ
तारीखों, तार, संरचनाओं: के साथ काम करने के लिए अंतर्निहित कार्यों की एक बड़ी संख्या है
गणितीय कार्यों के साथ (गोलाई, लघुगणक, मूल, त्रिकोणमिति)
एकत्रीकरण कार्यों के साथ (योग, न्यूनतम, अधिकतम, औसत ...)
यदि उपरोक्त सभी पर्याप्त नहीं थे, तो आप कस्टम फ़ंक्शंस (jython, java) का उपयोग कर सकते हैं

जैसा कि आप देख सकते हैं, सुअर हाइव के समान कर सकते हैं। अंतर केवल आंकड़ों की प्रस्तुति और भाषा में है। लेकिन यह ठीक यही अंतर है जो सुअर को एक नए स्तर पर ले जाता है।

चलो सुअर पर करीब से नज़र डालें।

यह ढांचा विशेष डेटा संरचनाओं के साथ काम करता है - टपल और बैग।

Tuple खेतों का एक व्यवस्थित सेट है। एक संरचना जिसके खेतों को सूचकांक और / या नाम से पहुँचा जा सकता है।
बैग - टपल का संग्रह (सेट)।

सुअर लैटिन बुनियादी कार्य:

लोड
स्टोर
उत्पन्न
शामिल हों
ग्रुप
फ़िल्टर
यूनिअन
DISTINCT
आदेश

आइए एक उदाहरण देखें कि आप सुअर के साथ काम करने की प्रक्रिया में डेटा को कैसे बदल सकते हैं। हम RTB एक्सचेंज की लॉग फाइल के साथ काम करेंगे। डेटा निम्नानुसार प्रस्तुत किए गए हैं:

समय - समय
bid_id - बोली पहचानकर्ता,
user_id - उपयोगकर्ता आईडी
dsp_id - बोलीदाता (खिलाड़ी) की पहचानकर्ता
बोली - बोली

सुअर - डेटा लोडिंग (लोड)

लोड करने के लिए LOAD फ़ंक्शन का उपयोग किया जाता है, हम विभाजक वर्ण 't' और डेटा हस्ताक्षर भी निर्दिष्ट करते हैं (आप आवश्यक रूप से प्रकार निर्दिष्ट कर सकते हैं)।

 --   HDFS (Pig   Hadoop) fs -rm -f -r -skipTrash /data/pig/out --    'raw_data' raw_data = LOAD '/data/pig/example/' USING PigStorage('\t') AS (time, bid_id, user_id, dsp_id, bid:int);

आउटपुट में हमें ऐसी संरचना मिलती है (ट्यूपल)। प्रश्नों में, इसके क्षेत्रों को एक डॉट के माध्यम से एक्सेस किया जा सकता है। उदाहरण के लिए: raw_data.dsp_id

 raw_data -> tuple   . ------------------------------------------------------------------------------------------- time, bid_id, user_id, dsp_id, bid ------------------------------------------------------------------------------------------- (2014.02.14 14:08:27.711, 56949, 45234534553459, DSP-2, 12) (2014.02.14 14:08:28.712, 61336, 45221696259999, DSP-1, 56) (2014.02.14 14:08:29.713, 74685, 45221699381039, DSP-2, 89) (2014.02.14 14:08:30.714, 56949, 45221695781716, DSP-1, 21) (2014.02.14 14:08:25.715, 27617, 45221682863705, DSP-3, 22)

सुअर - Iterative डाटा प्रोसेसिंग (पूर्व - सामान्य)

FOREACH - GENERATE आपको डेटा सेट के माध्यम से "रन" करने की अनुमति देता है और प्रत्येक रिकॉर्ड के लिए कुछ ऑपरेशन लागू करता है, या बस विशिष्ट फ़ील्ड्स को आउटपुट में भेजता है, जो सब कुछ की आवश्यकता नहीं है।

 -- .  timestamp   SUBSTRING norm_data = FOREACH raw_data GENERATE SUBSTRING(time, 0,10) AS date, dsp_id, bid;

आउटपुट में हमें एक ही सेट मिलता है, लेकिन एक छंटनी की तारीख के साथ, और केवल दो फ़ील्ड: dsp_id, बोली।

 norm_data -> tuple       --------------------------------------- date, dsp_id, bid --------------------------------------- (2014.02.14, DSP-2, 12) (2014.02.14, DSP-1, 56) (2014.02.14, DSP-2, 89) (2014.02.14, DSP-1, 21)

सुअर - डेटा ग्रुपिंग (ग्रुप)

ग्रुप - आपको एक गैर-तुच्छ संरचना प्रदान करते हुए, समूह डेटा की अनुमति देता है।

 --  dsp_id  date group_norm_data = GROUP norm_data BY (dsp_id, date);

हमारे पास आउटपुट पर:

एक कुंजी के रूप में समूह। यह समूह उपसर्ग के माध्यम से पहुँचा जा सकता है।

और norm_data के साथ उपसर्गों का एक संग्रह

 group_norm_data -> (  ) : [ (norm_data), (norm_data) ] ---------------------------------------------------------------------------------- ( group), array of norm_data ---------------------------------------------------------------------------------- ( (DSP-1, 2014.02.14), {(2014.02.14, DSP-1, 56), (2014.02.14, DSP-1, 21)} ) ( (DSP-1, 2014.02.17), {(2014.02.17, DSP-1, 34), (2014.02.17, DSP-1, 24)} ) ( (DSP-2, 2014.02.14), {(2014.02.14, DSP-2, 89), (2014.02.14, DSP-2, 12)} )

सुअर - समग्र झाड़ू (FLATTEN)

कभी-कभी एक रेखीय संरचना ("सीधा") में समुच्चय को तैनात करना आवश्यक होता है।

इसके लिए एक फ्लैटन फ़ंक्शन है।

 --      ft_group_norm_data = FOREACH group_norm_data GENERATE FLATTEN(group), FLATTEN(norm_data);

एक जटिल समूहीकृत संरचना से, हमें टुपल्स का सीधा सेट मिलता है।

 ft_group_norm_data -> tuple    ---------------------------------------------------------------------- dsp_id, date date dsp_id bid ----------------------------------------------------------------------- (DSP-1, 2014.02.14, 2014.02.14, DSP-1, 56) (DSP-1, 2014.02.14, 2014.02.14, DSP-1, 21) (DSP-1, 2014.02.15, 2014.02.15, DSP-1, 15) (DSP-1, 2014.02.15, 2014.02.15, DSP-1, 31)

सुअर - एकत्रीकरण कार्य (SUM)

कुछ गिनते हैं। उदाहरण के लिए, प्रत्येक बोलीदाता द्वारा किए गए दैनिक दांव की राशि।

 --   ,    sum_bids_dsp = FOREACH group_norm_data GENERATE group, SUM(norm_data.bid) AS bids_sum;

 sum_bids_dsp ->  : bids_sum ------------------------------------------------------ group, bids_sum ------------------------------------------------------ ( (DSP-1, 2014.02.16), 82) ( (DSP-1, 2014.02.17), 58) ( (DSP-2, 2014.02.14), 101) ( (DSP-2, 2014.02.16), 58)

सुअर - ग्रुप सभी

एक नमूने में "रिकॉर्ड" की संख्या की गणना करना अक्सर आवश्यक होता है। बस चयन में COUNT लागू करने में विफल हो जाएगा। डेटा को एक समूह में ध्वस्त किया जाना चाहिए और उसके बाद ही एकत्रीकरण कार्यों को लागू करना चाहिए।

 --  ,   . --      . group_all = GROUP sum_bids_dsp ALL;

आउटपुट में हमारे पास एक समूह है - "सभी" और सभी पिछली इकाइयों का एक संग्रह।

 ( all, { ((DSP-1,2014.02.14),77), ((DSP-1,2014.02.15),67), ((DSP-1,2014.02.16),82),((DSP-1,2014.02.17),58),((DSP-2,2014.02.14),101),((DSP-2,2014.02.16),58),((DSP-2,2014.02.17),123),((DSP-3,2014.02.14),22),((DSP-3,2014.02.15),109),((DSP-3,2014.02.16),136),((DSP-3,2014.02.17),81) } )

अब राशि और राशि की गणना करें

 summary = FOREACH group_all GENERATE COUNT(sum_bids_dsp), SUM(sum_bids_dsp.bids_sum);

निकास

 ------------------------------------------------------ count, sum ------------------------------------------------------ (11, 914)

मेरी राय में, यह वही है जो आपको चाहिए। डेटा प्रोसेसिंग को एक क्रमबद्ध तरीके से प्रस्तुत किया जाता है। सब कुछ आसानी से चरणों में टूट जाता है। प्रत्येक चरण टिप्पणियों के साथ प्रदान किया जा सकता है।

कुल:

सुअर पेशेवरों:

प्रक्रियात्मक दृष्टिकोण। आदेश! भाषा आपको ब्लॉक में तर्क को तोड़ने की अनुमति देती है, प्रत्येक चरण को टिप्पणियों के साथ विस्तार से वर्णित किया जा सकता है।
हुड के तहत MapReduce गठन। यह एमआर के चारों ओर स्ट्रैपिंग से संबंधित बहुत अधिक ओवरहेड लेता है। डेटा मॉडल, इनपुट और आउटपुट प्रारूप, एमआर कार्य श्रृंखला का विवरण।
अन्तरक्रियाशीलता। विभिन्न स्लाइस में डेटा का विश्लेषण करने के लिए अच्छा है।
विकास की गति। कोई निर्भरता नहीं, बनाता है

सुअर विपक्ष:

सब कुछ सुअर लैटिन में नहीं डाला जा सकता है
HQL के विपरीत, डेटा संरचनाओं के साथ सुअर लैटिन अधिक जटिल है
UDF के लिए, Jython का उपयोग किया जाता है। यह कुछ पुस्तकालयों के उपयोग को सीमित कर सकता है।

सारांश:

छत्ता छोटे और सरल नमूनों के लिए अच्छा है। HQL SQL के समान है, इसलिए आप इस ढांचे के साथ बहुत जल्दी काम करना शुरू कर सकते हैं।
सुअर को भाषा और डेटा संरचनाओं को सीखने की आवश्यकता होती है। लेकिन फिर, एक बार जब आप इसका पता लगा लेते हैं, तो आपको एक और अधिक शक्तिशाली उपकरण मिल जाता है जिससे जटिल और बहु-स्तरीय नमूनों को लागू करना आसान हो जाता है। सुलभ और प्रासंगिक टिप्पणियों के साथ आपको सरल और व्यवस्थित कोड मिलता है।

यदि आप और आपके सहकर्मी SQL के बारे में अच्छी तरह से जानते हैं, तो रोजाना इसके साथ काम करते हैं, और आप उग्र सवालों से शर्मिंदा नहीं होते हैं, तो हाइव एक बेहतरीन उपाय है। हालांकि, यदि आप कभी-कभी SQL के साथ काम करते हैं और आपका डेटा वर्कफ़्लो सरल प्रश्नों में फिट नहीं होता है, तो यह निश्चित रूप से एक दिन बिताने और सुअर को छांटने लायक है। भविष्य में, यह आपके समय और आपके सहयोगियों को बचा सकता है।

छत्ता बनाम सुअर। मुझे ईटीएल के लिए क्या चाहिए?

एक दिन खोना बेहतर है, लेकिन फिर पांच मिनट में उड़ान भरें

मधुमुखी का छत्ता

सूअर

More articles: