Hadoop – hive – பகுதி 4

நித்யா June 20, 2018 0 Comments

Facebook நிறுவனம் hadoop-ஐ பயன்படுத்தத் துவங்கிய காலங்கள் முதல், அதனிடம் வந்து சேரும் தரவுகளின் அளவு 1GB, 1TB, 15TB என உயர்ந்து கொண்டே சென்றது. அப்போது அவற்றினை அலசி தரவுச் சுருக்கங்களைத் தேர்ந்தெடுப்பதற்கு oracle database-ஐயும் பைதான் மொழியையும் பயன்படுத்தியது. ஆனால் வருகின்ற மூலத் தரவுகளின் அளவும், வடிவங்களும் அதிகரிக்க அதிகரிக்க data analysis தேவைக்கென ஒரு புதிய முறை கண்டுபிடித்தாக வேண்டி இருந்தது. அப்போதுதான் facebook நிறுவனம் இத்தகைய datawarehouse தேவைகளைப் பூர்த்தி செய்வதற்கென்றே Hive எனும் ஒரு புதிய கருவியைக் கண்டுபிடித்தது. இக்கருவி rdbms-ன் கோட்பாடுகளை உள்ளடக்கிய, SQL-ஐப் போன்றே செயல்படக் கூடிய, ஆனால் முழுக்க முழுக்க analysis தேவைக்கென உருவாக்கப்பட்ட ஒரு data warehouse framework ஆகும். இதனை transactional database-ஆகப் பயன்படுத்த முடியாது. பின்னாளில் இது Apache நிறுவனத்தால் திறந்த மூல மென்பொருள் கருவியாக மாற்றப்பட்டு மக்கள் பயன்பாட்டிற்கு வழங்கப்பட்டது.

Pig மற்றும் hive ஆகிய இரண்டும் sql-ஐப் போன்ற மொழியைப் பயன்படுத்தி mapreduce jobs-ஐ எழுதி hadoop-ல் உள்ள தரவுகளைக் கையாளும். Pig பயன்படுத்துவது piglatin என்றும், Hive பயன்படுத்துவது HQL என்றும் அழைக்கப்படும். இவை இரண்டின் செயல்பாடுகளும் ஒத்திருந்தாலும், Hive என்பது analysis தேவைக்கேன்றே உருவாக்கப்பட்ட பிரத்தியேகக் கருவியாக விளங்குவதால், data warehouse மற்றும் BI Reporting துறையில் இருப்பவர்கள் hive-ஐயும், ஆராயிச்சித் துறையில் இருப்பவர்கள் மற்றும் நிரலாளர்கள் pig-ஐயும் தேர்ந்தெடுப்பார்கள். மேலும் Hive என்பது வடிவான தகவல்களை மட்டுமே கையாளும். அதாவது hdfs-ல் கோப்பு வடிவில் சேமிக்கப்பட்டுள்ள தரவுகளும் hive-ல் அட்டவணை வடிவில் இருக்கும்.

Hive-ன் சிறப்பம்சங்கள்:

• HQL என்பது Hive Query Language எனப்படும். இதன் வடிவம் sql-ஐப் போன்றதே. Hive> எனப்படும் command line interface மூலம் இதனை நாம் இயக்கலாம்.
• HQL-ன் இயக்கமானது தொடர்ச்சியாக இயங்கக் கூடிய பல்வேறு mapreduce jobs-ஆக அமையும். hive கட்டமைப்பில் இதன் இயக்கத்தைப் பற்றித் தெளிவாகப் பார்க்கலாம்.
• இதில் database மற்றும் tables தனியாக உருவாக்கப்படுகின்றன. அதன் பின்னர்தான் தகவல்கள் உட்செலுத்தப்படுகின்றன.
• இது structured data-வுக்கென்றே சிறப்பாக வடிவமைக்கப்பட்ட கருவியாதலால், query optimization-க்குத் தேவையான பல்வேறு காரணிகள்(udf, filtering etc) இதில் காணப்படுகின்றன. Query optimization என்பது query-ன் இயக்கத்தை இன்னும் துரிதமாக்க உதவுவதாகும்.
• Hive-ல் உள்ள அட்டவணைகளின் schemaபற்றிய தகவல்களை சேமிப்பதற்காக Metastore-ஐயும், அந்த அட்டவணைகளில் process-செய்யப்பட்ட அல்லது செய்யப்படப்போகும் தரவுகளை சேமிப்பதற்காக hdfs/hbase-ஐயும் hive பயன்படுத்துகிறது.
• mysql, derby, mongodb போன்ற ஏதாவதொரு relational database-ஐ நாம் metastore-ன் தேவைக்காகப் பயன்படுத்தலாம். jdbc, web gui போன்றவற்றைக் கொண்டு அதனுடன் இணைப்பை ஏற்படுத்தலாம்.
• Derby-ஆனது தனியொரு பயனரை மட்டும் அதரிக்கிறது. ஆனால் Mysql பல்வேறு பயணர்களை அதரிப்பதால் இதனையே பெரும்பாலோர் தேர்ந்தெடுக்கின்றனர். single metadata எனும் போது derbyஐயும், shared metadata எனும்போது mysqlஐயும் பயன்படுத்தலாம்.
• hdfs-க்கும் hive-க்கும் இடையில் தரவுகளை பரிமாறிக் கொள்வதற்கு web ui, command line, hd insight ஆகிய 3 வகையான interfaces உள்ளன. இப்பகுதியில் நாம் பயன்படுத்தியுள்ள அனைத்து உதாரணங்களும் hive command line மூலம் காட்டப்பட்டுள்ளன.
• Mapreduce-க்கு மாற்றாக metadata-ன் மீது இயக்கப்படுகின்ற query வடிவமே HQL என்று அழைக்கப்படுகிறது. இந்த query வடிவத்தை இயக்குகின்ற இயந்திரம் தான் HiveQL Process Engine ஆகும்.
• பின்வரும் 4 விதமான கோப்பு வடிவங்களை hive ஆதரிக்கிறது : text, sequence, orc & rc files.

Hive-ஐ நிறுவுதல்:

1. Hive-ஐ பதிவிறக்கம் செய்து, பிரித்து, நமக்கு வேண்டிய இடத்தில் மாற்றி வைக்கவும்.

$ wget www-us.apache.org/dist/hive/hive-2.2.0/apache-hive-2.2.0-bin.tar.gz
$ tar -xzvf apache-hive-2.2.0-bin.tar.gz
$ sudo mv ~/apache-hive-2.2.0-bin /usr/local

2. hive-ன் 2.2.0-வுடன் ஒத்துப்போகும் hadoop version-ஆன 2.6.5-வையும் பதிவிறக்கம் செய்து அதே இடத்தில் மாற்றி வைத்துக் கொள்ளவும்.

$ wget redrockdigimark.com/apachemirror/hadoop/common/hadoop-2.6.5/hadoop-2.6.5.tar.gz
$ tar -xzvf hadoop-2.6.5.tar.gz
$ sudo mv ~/hadoop-2.6.5 /usr/local

/usr/local எனுமிடத்தில் hive மற்றும் hadoop சேமிக்கப்பட்டுள்ளதைக் காணலாம்.

இந்த hadoop-ன் புதிய version-ல் அது செயல்படுவதற்குத் தேவையான அனைத்து விதமான மாற்றங்களையும் hadoop-env.sh,core-site.xml,mapred-site.xml,hdfs-site.xml முதலிய கோப்புகளிலும் செய்துவிடவும். இவை அனைத்தும் /usr/local/hadoop-2.6.5/etc/hadoop எனுமிடத்தின் கீழ் காணப்படும். இதை எவ்வாறு செய்வது என்பது பற்றி நாம் முன்னரே பார்த்துள்ளோம்.

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

$ vim ~/.bashrc
export HIVE_HOME=/usr/local/apache-hive-2.2.0-bin
export PATH=$PATH:$HIVE_HOME/bin
export HADOOP_INSTALL=/usr/local/hadoop-2.6.5
export PATH=$PATH:$HADOOP_INSTALL/bin
$ source ~/.bashrc

3. hive-config.sh-க்குள் பின்வருமாறு சேர்க்கவும்

$ vim /usr/local/apache-hive-2.2.0-bin/bin/hive-config.sh
export HADOOP_INSTALL=/usr/local/hadoop-2.6.5

4. பொதுவாக hive-ஆனது அதன் அட்டவணைகளின் schemaபற்றிய தகவல்களை சேமித்து வைப்பதற்காக derby-ன் metastore-ஐத்தான் பயன்படுத்தும். ஆனால் derby-ஐ விட mysql சிறந்தது. ஏனெனில் mysql-ஐ backend-ல் பயன்படுத்தும்போது ஒரே நேரத்தில் பல்வேறு பயனர்கள் hive-ஐத் தொடர்பு கொள்ள முடியும். இவ்வசதி derby-ல் கிடையாது. எனவே இப்போது mysql-ஐ நிறுவுவதற்கான கட்டளைகள் பின்வருமாறு அமையும்.

4.1. mysql server-ஐ நமது கணினியில் பதிவிறக்கம் செய்து நிறுவவும்.
$ sudo apt-get install mysql-server

4.2. அதற்கான java connector-ஐயும் நிறுவவும். இதுவே hive-வுடன் இணைப்பதற்கு உதவும்.
$ sudo apt-get install libmysql-java

4.3. அந்த java connector-க்கு hive-ன் lib-க்குள் சென்று ஒரு இணைப்பை (soft link) உருவாக்கவும்.
$ ln -s /usr/share/java/mysql-connector-java.jar /usr/local/apache-hive-2.2.0-bin/lib/mysql-connector-java.jar

4.4. பின்னர் hive-ன் conf-க்குள் உள்ள hive-default.xml.template எனும் கோப்பினை hive-site.xml
என மாற்றி அதற்குள் உள்ள மதிப்புகளைக் கீழே குறிப்பிட்டுள்ளவாறு மாற்றி/சேர்த்து அமைக்கவும்.
$ cp /usr/local/apache-hive-2.2.0-bin/conf/hive-default.xml.template /usr/local/apache-hive-2.2.0-bin/conf/hive-site.xml
$ vim /usr/local/apache-hive-2.2.0-bin/conf/hive-site.xml

system:java.io.tmpdir
/tmp/hive/java
system:user.name
${user.name}
javax.jdo.option.ConnectionURL
jdbc:mysql://localhost/metastore?createDatabaseIfNotExist=true&useSSL=false
javax.jdo.option.ConnectionDriverName com.mysql.jdbc.Driver
javax.jdo.option.ConnectionUserName
nithya

javax.jdo.option.ConnectionPassword
nithya

இதில் கொடுக்கப்பட்டுள்ள nithya , nithya என்பது mysql-ஐ அணுகுவதற்கு முழுமையான அனுமதிகள் பெற்ற பயனர்பெயர் மற்றும் கடவுச்சொல் ஆகும்.
4.5. hive-site.xml -க்குள் system:java.io.tmpdir -ன் மதிப்பாக நாம் கொடுத்துள்ளது போலவே ஒரு directory-ஐ உருவாக்கிவிடவும்.
$ mkdir -p /tmp/hive/java
4.6. hadoop-ஐ இயக்கி அதன் root (/) -க்குள் user/hive எனும் directory-ஐ உருவாக்கவும். hive இங்கிருந்துதான் தரவுகளை எடுத்து process செய்யும். மேலும் hive-ல் உருவாக்கப்படும் schema, tables, partitions, buckets அனைத்தும் இந்த இடத்தில் warehouse எனும் directory-ஐ உருவாக்கி அதன் கீழ் சேமிக்கப்படும்.
$ /usr/local/hadoop-2.6.5/sbin/start-all.sh
$ hadoop fs -mkdir /user
$ hadoop fs -mkdir /user/hive
$ hadoop fs -chmod g+w /user/hive

4.6. இது hive-க்கும் mysql-க்கும் முதன்முதலில் தொடர்பை ஏற்படுத்த உதவும். இதன் பின்னர் இரண்டும் sync-ல் செயல்பட்டுக் கொண்டிருக்கும்.
$ /usr/local/apache-hive-2.2.0-bin/bin/schematool -initSchema -dbType mysql

5. இது hive shell-ஐ உருவாக்கும்.
$ hive

Hive-ன் செயல்பாடுகள்:

1. Hive-ல் பயன்படுத்தப்படும் மிக அடிப்படையான கட்டளைகள் கீழே கொடுக்கப்பட்டுள்ளன. அதற்கான விளக்கங்களை வலத்துப்புறத்தில் காணலாம்.

> create database exercises; (ஒரு db-ஐ உருவாக்கும்)
> show databases; (அனைத்து db-ஐயும் பட்டியலிடும் )
> alter table states_of_india rename to indian_states;(ஒரு table-ஐ பெயர்மாற்றம் செய்யும்)
> show tables; (அனைத்து db-ஐயும் பட்டியலிடும்)
> drop table indian_states; (அனைத்து tables-ஐயும் பட்டியலிடும்)
> drop view aaaa; (ஒரு view-ஐ நீக்க உதவும்)
> drop database sample; (ஒரு db-ஐ நீக்க உதவும்)

கீழ்க்கண்ட உதாரணத்தில் exercises எனும் பெயர் கொண்ட db-ஐ உருவாக்கியுள்ளோம்.

உடனே hadoop-ல் /user/hive எனுமிடத்தில் சென்று பார்த்தீர்களானால் warehouse எனும் directory உருவாக்கப்பட்டிருக்கும். அதற்குள் சென்று பார்த்தால், நாம் உருவாக்கிய exercises.db என்பது காணப்படும். இனிமேல் இந்த db-க்குள் தான் நாம் உருவாக்கப்போகும் அனைத்தும் காணப்படும்.

2. RDBMS-ஐப் போலவே இதிலும் அட்டவணைகளை உருவாக்கி பல்வேறு operations-ஐச் செய்யலாம். ஆனால் இதில் உருவாக்கப்படும் அட்டவணைகளை internal, external என்று இரண்டு விதமாகப் பிரிக்கலாம். இவைகள் முறையே data on schema, schema on dataஎன்று அழைக்கப்படுகின்றன. இவ்விரண்டுக்கும் உள்ள வித்தியாசம் பற்றியும், எவ்வகையில் இவ்விதம் அழைக்கப்படுகின்றன என்பது பற்றியும் கீழே காணலாம்.

2.1 நமது கணினியில் employees.txt , women.txt ஆகிய கோப்பிற்குள் ஒருசில விவரங்கள் உள்ளன. அவற்றை நாம் hive-ல் அட்டவணைகளாக உருவாக்கப் போகிறோம். employees எனும் கோப்பிற்குள் உள்ளவற்றை internal table-ஆகவும், women எனும் கோப்பிற்குள் உள்ளவற்றை external table-ஆகவும் உருவாக்கப்போகிறோம். முதலில் இவ்விரண்டு கோப்புகளையும் /user/hive எனுமிடத்திற்கு மாற்றவும். அப்போதுதான் hive எடுத்து process செய்யும்.

$ hadoop fs -put ~/employees.txt /user/hive;
$ hadoop fs -put ~/women.txt /user/hive;

2.2 employees எனும் பெயர்கொண்ட ஒரு internal அட்டவணையை உருவாக்குவதற்கான கட்டளைகள் பின்வருமாறு.
hive-க்குள் சென்று exercises db-க்குள் செல்லவும்.
> use exercises;

முதலில் employees எனும் அட்டவணையை மட்டும் உருவாக்குவதற்கான கட்டளை பின்வருமாறு.
> create table employees (sid int, fname string, lname string, age int, mob string, city string) row format delimited fields terminated by ‘,’;

இப்போது கோப்பிற்குள் உள்ளவற்றை அட்டவணைக்குள் மாற்றுவதற்கான கட்டளை பின்வருமாறு.
>load data inpath ‘/user/hive/employees.txt’ into table employees;

அடுத்து அட்டவணைக்குள் சென்று எல்லாம் சரியாக ஏற்றப்பட்டுவிட்டதா என சரிபார்க்கவும்.
>select * from employees;

கடைசியாக hadoop-க்குள் சென்று பார்த்தால் நாம் உருவாக்கிய அட்டவணை exercise db-க்குள் காணப்படும். அதற்குள் சென்று பார்த்தால் அந்த அட்டவணைக்கான மூலக்கோப்பு காணப்படும். இம்முறையில் data-ஆனது schema-க்குள் சென்று சேருவதால் இது ‘data on schema’ என்றழைக்கப்படுகிறது.
>hadoop fs -ls /user/hive/warehouse/exercises.db/employees

2.3 women_employees எனும் பெயர்கொண்ட ஒரு external அட்டவணையை உருவாக்குவதற்கான கட்டளைகள் பின்வருமாறு.
women_employees எனும் பெயர் கொண்ட அட்டவணையை external-ஆக உருவாக்குவதற்கு create external table எனும் வார்த்தை வெளிப்படையாகக் கொடுக்கப்பட்டுள்ளது. மேலும் hadoop-ன் எந்த இடத்தில் உருவாக்க வேண்டும் என்பதை location மூலம் குறிப்பிட்டுள்ளது.
> create external table women_employees (sid int, fname string, lname string, age int, mob string, city string) row format delimited fields terminated by ‘,’ location ‘/user/hive/aaaa/women_employees’;

கோப்பிற்குள் உள்ளவற்றை அட்டவணைக்குள் மாற்றுவதற்கான கட்டளை பின்வருமாறு.
> load data inpath ‘/user/hive/women.txt’ into table women_employees;

இப்போது hadoop-ல் சென்று பார்த்தால் நாம் உருவாக்கிய அட்டவணை exercises db-ன் கீழ் காணப்படாது. நாம் குறிப்பிட்டுள்ள location-ல் தான் உருவாக்கப்பட்டிருக்கும். அந்த location,
hadoop-ல் இல்லையென்றாலும், அதனை உருவாக்கி அதற்குள் கோப்புகளை சேமிக்கும். எனவே இது “Schema on data” என்றழைக்கப்படுகிறது.
> hadoop fs -ls /user/hive/aaaa/women_employees;

3. Partitions என்பது ஒரு அட்டவணையை பல்வேறு பகுதிகளாகப் பிரிப்பதே ஆகும். ஒரு பெரிய அட்டவணையிலிருந்து நமக்குத் தேவைப்படும் columns-ஐ மட்டும் எடுத்து, அவற்றை நமக்கேற்றவாறு பிரித்து, ஒரு சிறிய அட்டவணையாக சேமிப்பதே partitions எனப்படும். அவ்வாறு பிரித்து எடுப்பதற்கு நாம் பயன்படுத்துவது partition key என்றழைக்கப்படும்.

மேலே நாம் உருவாக்கிய employee அட்டவணையிலிருந்து fname, mob columns-ல் இருக்கும் தரவுகளை மட்டும் எடுத்து emp எனும் ஒரு சிறிய அட்டவணையை நாம் உருவாக்கப் போகிறோம். அடுத்து அதிலுள்ளவற்றை city column-ல் இருக்கும் மதிப்புகளின் அடிப்படையில் பிரித்து சேமிக்கப்போகிறோம். இதிலுள்ள படிகள் பின்வருமாறு.

பின்வரும் கட்டளை emp எனும் ஒரு அட்டவணையை உருவாக்கி, அதில் சேமிக்கப்படும் தரவுகளை city-ன் அடிப்படையில் பல்வேறு பகுதிகளாகப் பிரிக்கும். அடுத்த கட்டளை அட்டவணை dynamic-ஆகப் பிரிக்கப்படுவதை அனுமதிக்கும் ஒரு பண்பின் மதிப்பினை set செய்கிறது.
> create table emp(fname string,mob string) PARTITIONED BY(city string);
> set hive.exec.dynamic.partition.mode=nonstrict;

partition அட்டவணைக்குள் தரவுகளை ஏற்றுவதற்கான கட்டளை பின்வருமாறு.
>insert overwrite table emp PARTITION(city)
SELECT lname,mob,city from employees;

இப்போது அந்த அட்டவணையில் சென்று பார்த்தால் தரவுகள் அனைத்தும் city-ன் அடிப்படையில் பிரிக்கப்பட்டிருப்பதைக் காணலாம்.
> select * from emp;

hadoop-ல் சென்று பார்த்தால் city-ன் மதிப்புகளைப் பொறுத்து பல்வேறு பகுதிகள் பிரிக்கப்பட்டிருப்பதைக் காணலாம்.
> hadoop fs -ls /user/hive/warehouse/exercises.db/emp

4. Buckets என்பது Partitions-ன் தரவுகளை இன்னும் சிறு பகுதிகளாகப் பிரித்து துரிதமாக இயங்குவதற்கு ஏற்ற வகையில் சேமிக்கும். பின்புலத்தில் இயங்கும் hashing algorithm இதற்காகப் பயன்படுகிறது. emp எனும் பெயர் கொண்ட partition-ல் இருந்து, ep எனும் பெயர் கொண்ட bucket-ஐ உருவாக்குவதில் உள்ள படிகள் பின்வருமாறு.

எதனடிப்படையில் எத்தனை buckets உருவாக்க வேண்டும் எனப் பின்வருமாறு குறிப்பிடலாம்.
> create table ep(fname string,mob string,city string) CLUSTERED BY(city) into 3 buckets row format delimited fields terminated by ‘,’;

partition-ல் இருந்து bucket-க்குள் தரவுகளை ஏற்றுவதற்கான கட்டளை பின்வருமாறு.
> from emp insert overwrite table ep SELECT fname,mob,city;

hadoop-ல் சென்று பார்த்தால் ep அட்டவணையின் கீழ் 000000, 000001, 000002 எனும் பெயர் கொண்ட 3 buckets உருவாக்கப்பட்டிருப்பதைக் காணலாம்.
> hadoop fs -ls /user/hive/warehouse/exercises.db/ep

5. Views என்ற ஒன்றை hive-லும் உருவாக்கலாம். ஒரு query result-ஐ தற்காலிகமாக ஒரு புதிய பெயரில் சேமித்துக்கொள்வதை view என்போம். இங்கு age எனும் பெயர் கொண்ட view-ஐ உருவாக்குவதற்கான கட்டளை கீழே கொடுக்கப்பட்டுள்ளது.
> create view age as select * from employees where age>22;

6. Index என்பது அட்டவணையிலுள்ள அனைத்து தகவல்களையும் அணுகுவதற்கான ஒரு reference போன்று செயல்படும். ஒரு அட்டவணையிலுள்ள மிக முக்கிய columns-ன் மீது index-ஐ உருவாக்கி அதனடிப்படையில் நாம் மற்ற columns-ஐ அணுகலாம். Hive-ல் compact, bitmap எனும் 2 வகையான indexes உள்ளன. அதாவது cluster முறையில் பிரித்து வைக்கப்பட்டுள்ள தரவுகளை அதன் index கொண்டு தேடும்போது,
• compact index என்பது நாம் தேடுகின்ற மதிப்பு மற்றும் அது சேமிக்கப்பட்டுள்ள தொகுதியினை (value, block-id) எனும் வடிவில் key-value இணைகளாக சேமித்து வைத்திருக்கும்.
• bitmap index என்பது நாம் தேடுகின்ற மதிப்பு சேமிக்கப்பட்டுள்ள இடங்களின் பட்டியலை பட வடிவில் சேமித்திருக்கும். அதாவது (value , list of rows as a bitmap) எனும் வடிவில் key-value இணைகளாக இருக்கும்.
6.1 employees அட்டவணையிலுள்ள city column-ன் மீது compact index-ஐ உருவாக்குவதற்கான கட்டளை பின்வருமாறு.
create index city on table employees (city) as ‘org.apache.hadoop.hive.ql.index.compact.CompactIndexHandler’ with deferred rebuild;

6.2 அதே அட்டவணையில் உள்ள mob column-ன் மீது bitmap index-ஐ உருவாக்குவதற்கான கட்டளை பின்வருமாறு.
create index mobile on table employees (mob) as ‘bitmap’ with deferred rebuild;

6.3 பின்வரும் கட்டளை ஒரு அட்டவணையிலுள்ள அனைத்து index-ஐயும் வெளிப்படுத்தும்.
show formatted index on employees;

6.4 ஒரு index-ஐ நீக்குவதற்கான கட்டளை பின்வருமாறு.
drop index mobile on employees;

7. sql-ல் பயன்படுத்தப்படும் order by, group by, sort by, inner join, left outer join, right outer join, full outer joins & sub queries ஆகிய அனைத்தும் hive-லும் உள்ளன. இவைகளுக்கான queries-ஐப் பின்வருமாறு காணலாம்.
> select * from employees order by age;