Hadoop – pig – பகுதி 3

2006-ஆம் ஆண்டு Yahoo நிறுவனத்தின் ஒரு ஆய்வுத் திட்டமாக Pig என்பது உருவாக்கப்பட்டது. இது குறிப்பாக mapreduce வேலைகளைச் செய்வதற்காகப் பயன்படுத்தப்பட்டது. பின்னர் Apache நிறுவனம் 2008-ல் இதனை திறந்த மூல மென்பொருள் கருவியாக அறிவித்து வெளியிட்டது. Pig என்பது java, python போன்ற நிரலாக்க மொழிகளின் துணையில்லாமல், வெறும் SQL-ஐ வைத்து hadoop-ல் உள்ள தரவுகளை அணுக உதவும் கருவி ஆகும். Hadoop பற்றிய அடிப்படை அறிவு பெற்றிருந்தால் போதும். இதனைச் சுலபமாகக் கற்றுக் கொள்ளலாம். தரவுத்தளமானது ஒரு database-ஆக இருக்கும்போது அதனை SQL வைத்துக் கையாளலாம். ஆனால் அதுவே கோப்பு வடிவில் (files) இருக்கும்போது அவற்றையும் கையாள்வதற்கு pig பயன்படுகிறது.

PigLatin எனும் ஒரு நிரலாக்க மொழியை இது வழங்குகின்றது. இதனை வைத்து நிரலாளர்கள் செய்யும் அனைத்து வேலைகளையும் நாம் செய்யலாம். பொதுவாக java தெரியாதவர்கள் hadoop-வுடன் வேலை செய்வதற்கு சற்று தடுமாறுவார்கள் (mapreduce போன்ற இடங்களில்). அவர்களின் சிரமத்தைக் கலைவதற்காக வந்ததே PigLatin ஆகும். இதில் பயன்படுத்தப்படும் பெரும்பாலான operators, built-in functions, data types ஆகியவை SQL-ன் செயல்பாடுகளை ஒத்திருக்கும். இதை வைத்து எழுதப்படுவதே pig scripts ஆகும்.

இத்தகைய pig scripts-ஐ இயக்குவதற்கு நாம் grunt shell, user defined functions, embeddedபோன்ற ஏதாவதொன்றை நாம் தேர்ந்தெடுக்கலாம் (இப்பகுதியில் நாம் grunt shell-ஐப் பயன்படுத்தியுள்ளோம்). இயக்கத்தின் போது இவை தேவையான மாறுதல்களை அடைந்து கடைசியாக நமக்கு வேண்டிய வெளியீட்டினைக் கொடுக்கும். Pig-ன் கட்டமைப்பில் இத்தகைய இயக்கங்களை நிகழ்த்தி வெளியீட்டினைக் கொடுப்பதற்கு உதவும் மிக முக்கிய அங்கங்கள் பற்றியும் அவற்றின் செயல்பாடுகள் பற்றியும் பின்வருமாறு காணலாம்.

i) Parser : ஆரம்பத்தில் pig scripts-ன் வடிவம், தரவு வகை மற்றும் இன்ன பிற விஷயங்களை சோதித்து (syntax, type & other checking), DAG (directed acyclic graph) எனும் வரைபடத்தை உருவாக்குகிறது. இவ்வரைபடம் nodes & edges-ஐக் கொண்டிருக்கும். nodes என்பது scripts-ல் பயன்படுத்தப்பட்டுள்ள logical operators-ஐயும், edges என்பது piglatin-வாக்கியங்கள் மூலம் நடைபெறும் data flow-ஐயும் குறிக்கும்.
ii) Optimizer : இது DAG வரைபடத்தைப் பெற்றுக்கொண்டு அதிலிருந்து projection/pushdown ஆகிய வேலைகளைச் செய்கிறது.
iii) Compiler : Optimize செய்யப்பட்ட திட்டத்தினை தொடர்ச்சியான mapreduce jobs-ஆகcompile செய்கிறது.
iv) Execution Engine : Compiler உருவாக்கிய jobs-ஐ hadoop-ல் இயக்கி நமக்கு வேண்டிய வெளியீட்டினைக் கொடுக்கிறது.

Pig-ன் சிறப்பியல்புகள்:

i) Pig Latin மொழியைக் கொண்டு நிரலாளர்கள் Java பற்றிய அறிவு இல்லாமலேயே சிறப்பாக map reduce வேலைகளைச் செய்ய முடியும்.
ii) Multi query approach முறையைப் பயன்படுத்தி அதிகப்படியான நிரல்கள் எழுதப்படுவதைத் தவிர்க்கலாம். அதாவது java-ல் எழுதப்படுகின்ற 200 வரிகள் இம்முறையில் எழுதப்படும் 10 வரிகளுக்குச் சமமாகும்.
iii) SQL கொஞ்சம் தெரிந்தால் போதும். இதனைச் சுலபமாகக் கற்றுக்கொள்ள முடியும்.
iv) MapReduce -ல் காணப்படாத tuples, bags, maps போன்ற சிறப்புத் தரவு வகைகள் இதில் காணப்படுகின்றன. இவை nested data types என்று அழைக்கப்படுகின்றன.
v) அனைத்து வகைத் தரவுகளையும் (வடிவான மற்றும் வடிவற்ற) இது கையாள்கிறது.

Pig-ல் பயன்படுத்தப்படும் முக்கியப் பதங்கள்:

i) Atom : ஒவ்வொரு தனி மதிப்பும் atom என்று குறிக்கப்படும். இது எந்த தரவு வகையைச் சேர்ந்ததாகவும் இருக்கலாம். எடுத்துக்காட்டு: ‘Nithya’ or ‘30’
ii) Tuple : ஒரு ordered set-க்குள் உள்ள அனைத்து மதிப்புகளும் சேர்ந்து tuple என்று அழைக்கப்படும். இது table-ல் உள்ள row-ஐப் போன்றது. எடுத்துக்காட்டு: (Nithya,30)
iii) Bag : ஒரு unordered set-க்குள் உள்ள tuples அனைத்தும் சேர்ந்து Bag என்று அழைக்கப்படும். இது table-ஐப் போன்றது. எடுத்துக்காட்டு: {(Nithya,30),(Shrinivasan,35)}
ஆனால் அதற்காக ஒவ்வொரு row-ம் ஒரே எண்ணிக்கையினாலான தரவுத் தொகுப்பினைக் கொண்டிருக்க வேண்டுமென்றோ, அவை ஒரே வகைத் தரவாக இருக்க வேண்டும் என்றோ அவசியமில்லை. எடுத்துக்காட்டு: {(Nithya,30),(35,Shrinivasan,shrinivasan@gmail.com)}
iv) Inner bag : ஒரு bag-க்குள் மற்றொரு bag காணப்படின் அது inner bag என்று அழைக்கப்படும். எடுத்துக்காட்டு: {Nithya,30,{35,Shrinivasan,shrinivasan@gmail.com}}
v) Map : அடைப்புக்குறிக்குள் key மற்றும் value இணைகளாக காணப்படுபவை maps என்று அழைக்கப்படும். key என்பது chararray தரவு வகையைச் சேர்ந்ததாகவும், value என்பது எந்த வகைத் தரவாக வேண்டுமானாலும் இருக்கலாம். எடுத்துக்காட்டு: [Name#Nithya,age#30]
vi) Relations : ஒன்றுக்கும் மேற்பட்ட tuples-ஐ உள்ளடக்கிய bags-தான் relations என்றழைக்கப்படும். இதில் உள்ள தரவுகள் எந்த வரிசையில் வேண்டுமானாலும் process செய்யப்படலாம். வரிசைப்படுத்தப்பட்ட அதே முறையில் தான் process செய்யப்படும் என்று கிடையாது.

மற்றவைகளோடு Pig-ன் ஒப்பீடு:

Pig-ஆனது SQL, Hive போன்றவற்றுடன் எந்தெந்த விதங்களில் வேறுபடுகிறது, மேலும் மற்ற நீரலாக்க மொழிகளை வைத்து எழுதப்படுகின்ற mapreduce-க்கும் pig-க்கும் என்னென்ன வேறுபாடு ஆகியவற்றைப் பின்வருமாறு காணலாம்.

1. Pig-ஐ பதிவிறக்கம் செய்து, பிரித்து, நமக்கு வேண்டிய இடத்திற்கு மாற்றி, மாற்றப்பட்ட directory-க்கான முழு அனுமதிகளையும் பயனருக்கு வழங்கவும்.

$ wget redrockdigimark.com/apachemirror/pig/pig-0.17.0/pig-0.17.0.tar.gz
$ tar -xzvf pig-0.17.0.tar.gz
$ sudo mkdir /usr/local/pig
$ sudo mv ~/pig-0.17.0 /usr/local/pig/
$ sudo chown -R nithya:nithya /usr/local/pig/


2. நமது home directory-ல் உள்ள .bashrc எனும் கோப்பிற்குள் பின்வரும் விவரங்களை கடைசியில் இணைக்கவும்.

$ vim ~/.bashrc
export PIG_HOME=/usr/local/pig/pig-0.17.0/
export PATH=$PATH:/usr/local/pig/pig-0.17.0/bin
export PIG_CLASSPATH=$PIG_HOME/conf
$ source ~/.bashrc
.

3. pig நிறுவப்பட்டு விட்டதா என்பதை சோதிக்க பின்வரும் கட்டளையை அளித்துப் பார்க்கவும்.

$ pig -version

4. Pig-ஐ local mode (நமது கணினியில் உள்ள கோப்புகளை அணுகும்) மற்றும் mapreduce mode (hdfs-ல் உள்ள கோப்புகளை அணுகும்) எனும் இரண்டு விதங்களில் இயக்கலாம். இயல்பாக $ pig எனக் கொடுத்தால் இது mapreduce mode-ல் தான் செயல்படத் தொடங்கும். local-க்கு மாற்றுவதற்கு பின்வருமாறு கொடுக்கவும்.

$ pig -x local

இதன் வெளியீடாக grunt> shell உருவாகும். இதுவே Interactive mode-ஆக செயல்படும். இங்கு நாம் PigLatin வாக்கியங்களைக் கொடுத்து அதன் வெளியீட்டினை சோதித்துப் பார்க்கலாம் (dump operator மூலம்).
கீழ்க்கண்டவற்றில் = க்கு வலப்புறம் உள்ளது PigLatin வாக்கியம் ஆகும். இடப்புறம் உள்ளது relation என்றழைக்கப்படும். இது LOAD எனும் operator மூலம் womens.txt எனும் கோப்பிற்குள் உள்ளவற்றை a எனும் relation-ல் கொண்டு சேர்க்கிறது. பின்னர் dump operator மூலம் relation-ல் ஏற்றப்பட்டுள்ள விவரங்களை வெளிப்படுத்தியுள்ளது.

grunt> a = LOAD ‘Womens.txt’ USING PigStorage(‘,’);
grunt> dump a;

ஒவ்வொரு PigLatin வாக்கியமும் பின்வரும் வரையறைகளைப் பெற்று விளங்கும்.

• இறுதியில் ; (semi-colon) காணப்படும்.
• relation-வுடன் எப்போதும் சேர்ந்தே இருக்கும். இதுவே expression மற்றும் schema-வை உள்ளடக்கி இருக்கும்.
• load மற்றும் store தவிர்த்து, இன்ன பிற operators அனைத்தும் ஒரு relation-ஐயே உள்ளீடாக எடுத்துக்கொண்டு புதியதொரு relation-ஐ உருவாக்கக் கூடியவை. (Eg: join, cogroup).
• இதில் காணப்படும் பல்வேறு வகையான operators-தான் நாம் விரும்பும் அனைத்து வேலைகளையும் செய்ய உதவும்.

அடுத்து PigLatin வாக்கியங்களை உள்ளடக்கி smp.pig எனும் script file-ஐ உருவாக்கியுள்ளோம். இதனை இயக்குவதற்கு -x என்பதைப் பயன்படுத்தலாம்.

$ cat smp.pig
$ pig -x local smp.pig

5. Pig-ஐ mapreduce mode-ல் இயக்குவதற்கு பின்வரும் இரண்டு கட்டளைகளில் ஒன்றைத் தேர்ந்தெடுக்கலாம். இரண்டும் ஒன்றே ஆகும்.

$ pig
$ Pig –x mapreduce

இதன் வெளியீடாக grunt> உருவாவதைக் காணலாம். இதில் ஒருசில PigLatin வாக்கியங்களைக் கொடுத்து சோதிப்பதற்கு முன்னர், hdfs-ன் / -க்குள் நமக்கு வேண்டிய கோப்புகளைச் சேர்த்து விடவும். ஏனெனில் இது hdfs-ல் சென்றுதான் கோப்புகளைத் தேட ஆரம்பிக்கும்.

பின்வரும் கட்டளை மூலம் hdfs-ன் /pig_examples எனுமிடத்தில் Womens.txt எனும் கோப்பு உள்ளதை உறுதி செய்து கொள்ளலாம்.

$ hadoop fs -cat /pig_examples/Womens.txt

பின்னர் grunt> -க்குள் சென்று PigLatin வாக்கியங்களைக் கொடுக்கவும்.

grunt> a = LOAD ‘hdfs://localhost:54310/pig_examples/Womens.txt’ USING PigStorage(‘,’);
grunt> dump a;

அடுத்ததாக மேலே செய்து பார்த்தது போன்றே, smp.pig -க்குள் ஒருசில PigLatin வாக்கியங்களை அளித்து அதனை hdfs-ன் /pig_examplesஎனுமிடத்தில் சேர்க்கவும். இதனை exec அல்லது run ஆகிய கட்டளைகளைப் பயன்படுத்தி இயக்கலாம்.

grunt> exec smp.pig (or) grunt> run smp.pig


6. STORE எனும் operator ஒரு relation-ல் சேமிக்கப்பட்டுள்ள விவரங்களை hdfs-ன் ஏதேனும் ஒரு இடத்தில் சேமிக்கப் பயன்படுகிறது. எடுத்துக்காட்டாக a எனும் relation-ல் சேமிக்கப்பட்டுள்ள விவரங்களை pig_opt எனுமிடத்தில் சேமிப்பதற்கான கட்டளை பின்வருமாறு அமையும்.

grunt> STORE a INTO ‘hdfs://localhost:54310/pig_opt’ USING PigStorage(‘,’);

pig_opt1 எனுமிடத்தில் சென்று பார்த்தால் இரண்டு கோப்புகள் உருவாகியிருப்பதைக் காணலாம். அதில் part-m-ooooo எனும் கோப்பில் தான் a -ல் சேமிக்கப்பட்டுள்ள விவரங்கள் காணப்படும்.

$ hadoop fs -cat

7. Pig-ல் கீழ்க்கண்ட 4 விதமான operators உள்ளன. இவையே Illustration operators எனப்படும்.

Dump : ஒரு relation-ல் உள்ளவற்றை திரையில் வெளிப்படுத்தும்.
Describe : அதன் schema-வை வெளிப்படுத்தும்.
Explain : அதன் பல்வேறு இயக்கத் திட்டங்களை வெளிப்படுத்தும்.
Illustrate : படிப்படியான இயக்க நிகழ்வுகளை வெளிப்படுத்தும்.

இதில் dump-க்கான எடுத்துக்காட்டினை ஏற்கனவே பார்த்துள்ளோம். மற்ற மூன்றுக்குமான எடுத்துக்காட்டு பின்வருமாறு.

grunt> b = LOAD ‘hdfs://localhost:54310/pig_examples/Womens.txt’ USING PigStorage(‘,’) as (id:int,fname:chararray,lname:chararray,age:int,mobile:int,city:chararray);

grunt> describe b

grunt> explain b

grunt> illustrate b

8. GROUP எனும் operator ஒரு குறிப்பிட்ட மதிப்பின் அடிப்படையில், relation-ல் உள்ள தரவுகளை குழுக்களாக இணைத்து வெளிப்படுத்தும். பின்வரும் எடுத்துக்காட்டில் 28, 45 வயதில் உள்ள ஒன்றுக்கும் மேற்பட்ட நபர்கள் ஒரே குழுக்களாக இணைந்து வெளிப்படுத்தப் பட்டிருப்பதைக் காணலாம்.

grunt> i = GROUP b by age;
grunt> dump i;

அவ்வாறே கீழ்க்கண்ட எடுத்துக்காட்டில் (age, city) எனக் கொடுத்திருப்பதால், ஒரே வயதில் இருந்தாலும், அவர்கள் ஒரே ஊரைச் சேர்ந்தவர்களாக இருந்தால் மட்டுமே குழுக்களாக இணைக்கப்பட்டிருப்பதைக் காணலாம்.

grunt> j = GROUP b by (age, city);
grunt> dump j;

மேலும் All எனக் கொடுத்தால் அனைத்தும் ஒரே குழுவாக இணைக்கப்படும்.

grunt> k = GROUP b All;
grunt> dump k;


9. COGROUP எனும் operator ஒன்றுக்கும் மேற்பட்ட relations-ஐ எடுத்துக்கொண்டு அதனை கொடுக்கப்பட்ட மதிப்புகளுக்கு ஏற்றவாறு குழுக்களாக இணைத்து வெளிப்படுத்தும்.

grunt> c = LOAD ‘hdfs://localhost:54310/pig_examples/Employees.txt’ USING PigStorage(‘,’) as (id:int,fname:chararray,lname:chararray,age:int,mobile:int,city:chararray);

grunt> d = COGROUP b by age, c by age;
grunt> dump d;

10. JOIN எனும் operator ஒன்றுக்கும் மேற்பட்ட relations-ஐ இணைத்து, கொடுக்கப்பட்ட condition-ல் பொருந்தும் தகவல்களை மட்டும் எடுத்து வெளிப்படுத்தும் Inner Join போன்று செயல்படும். கீழ்க்கண்டவற்றில் age-ஐ வைத்துப் பொருத்தி இருவேறு relation-ல் இருக்கும் தகவல்களை வெளிப்படுத்தியுள்ளது.

grunt> e = JOIN b by age, c by age;
grunt> dump e;

அடுத்து age,city-ஐ வைத்துப் பொருத்தி தகவல்களை வெளிப்படுத்தியுள்ளது.

grunt> i = JOIN b BY (age,city), c BY (age,city);
grunt> dump i;

பின்வருவது left outer join போன்று செயல்படும். அதாவது இடப்புற relation-ல் இருக்கும் அனைத்து தகவல்களையும் வெளிப்படுத்தி, வலப்புற relation-ல் இருந்து condition-ல் பொருந்தும் தகவல்களை மட்டும் எடுத்து வெளிப்படுத்தும். இல்லையெனில் Null மதிப்பினை வெளிப்படுத்தும்.

grunt> f = JOIN b by age LEFT OUTER, c by age;
grunt> dump f;

பின்வருவது right outer join ஆகும். இது வலப்புறத்தில் இருக்கும் அனைத்துத் தகவல்களையும் வெளிப்படுத்தி, இடப்புறத்தில் இருந்து பொருந்தும் தகவல்களையும், இல்லையெனில் Null மதிப்பினையும் வெளிப்படுத்தும்.

grunt> g = JOIN b by age RIGHT, c by age;
grunt> dump g;

பின்வருவது full outer join ஆகும்.
grunt> h = JOIN b by age FULL, c by age;
grunt> dump h;

11. CROSS என்பது Cartesian Join போன்று செயல்படும். அதாவது இடப்புற relation-ல் இருக்கும் முதல் record, வலப்புறத்தில் உள்ள அனைத்து records-வுடனும் இணைத்து வெளிப்படுத்தப்படும். பின்னர், இதே முறையில் அனைத்து records-ம் வெளிப்படும்.

grunt> j = CROSS b, c;
grunt> dump j;

12. UNION எனும் operator இருவேறு relation-ல் இருக்கும் தரவுகளை இணைத்து வெளிப்படுத்தும்.

grunt> k = UNION b, c;
grunt> dump k;

13. SPLIT என்பது ஒரு relation-ல் இருக்கும் தகவல்களைக் குறிப்பிட்ட condition-ஐக் கொடுத்துப் பிரித்து, அதன் மதிப்புகளை இருவேறு relation-ல் சேமிக்க உதவும். கீழ்க்கண்ட எடுத்துக்காட்டில் b-ல் உள்ள தகவல்களில், 28 வயதுக்குக் கீழ் உள்ளவர்களை x-லும், அதற்கு மேல் உள்ளவர்களை y-லும் சேமித்துள்ளது.

grunt> SPLIT b into x if age<28, y if age>28;
grunt> dump x;
grunt> dump y;

.
14. FILTER என்பது condition-ல் பொருந்தும் தகவல்களை மட்டும் தேர்ந்தெடுத்து வெளிப்படுத்தும்.

grunt> l = FILTER b BY city == ‘Chennai’;
grunt> dump l;

15. DISTINCT என்பது ஒரு record-ஐ ஒருமுறை மட்டுமே வெளிப்படுத்தும்.

grunt> m = DISTINCT b by city;
grunt> dump m;

16. FOREACH எனும் operator

grunt> n = FOREACH b GENERATE fname,age,city;
grunt> dump n;

17. Order By என்பது தரவுகளை ஏறுவரிசையிலோ, இறங்கு வரிசையிலோ முறைப்படுத்தி வெளிப்படுத்தும்.

grunt> o = ORDER b by age DESC;
grunt> dump o;

18. LIMIT என்பது relation-ல் உள்ள தரவுகளை குறிப்பிட்ட அளவில் நிறுத்த உதவும்.

grunt> p = LIMIT b 4;
grunt> dump p;

மேற்கண்டவைகளோடு சேர்த்து pig-ல் பல்வேறு வகையான built-in-operators மற்றும் user-defined functions காணப்படுகின்றன. இதனைப் பற்றி இன்னும் விரிவாகக் கற்க விரும்புபவர்கள் வலைத்தளத்தின் உதவியை நாடவும். இப்போதைக்கு நமக்கு இது போதும். இதைவிட இன்னும் மேம்பாடான செயல்பாடுகள் கொண்ட Hive-ஐப் பற்றி அடுத்து தெரிந்து கொள்ள ஆரம்பிப்போம்.

Leave a Reply

%d bloggers like this: