Creating a Table using HBase Shell
You can create a table using the create command, here you must
specify the table name and the Column Family name.
The syntax to create a table in HBase shell is shown below.
create ‘<table name>’,’<column family>’
Example
Given below is a sample schema of a table named emp. It has
two column families: “personal data” and “professional data”.
Row key personal data professional data
You can create this table in HBase shell as shown below.
hbase(main):002:0> create 'emp', 'personal data', 'professional data'
Inserting Data using HBase Shell
How to create data in an HBase table? To create data in an HBase
table, the following commands is used:
• put command,
As an example, we are going to create the following table in
HBase.
Using put command, you can insert rows into a table. Its syntax is
as follows:
put ’<table name>’,’row1’,’<colfamily:colname>’,’<value>’
Inserting the First Row
Let us insert the first row values into the emp table as shown
below.
hbase(main):007:0> put 'emp','1','professional data:salary','50000'
0 row(s) in 0.0240 seconds
Updating Data using HBase Shell
You can update an existing cell value using the put command. To
do so, just follow the same syntax and mention your new value
as shown below.
put ‘table name’,’row ’,'Column family:column name',’new value’
The newly given value replaces the existing value, updating the
row.
Example
Suppose there is a table in HBase called emp with the following
data.
hbase(main):003:0> scan 'emp'
ROW COLUMN + CELL
row1 column = personal:name, timestamp = 1418051555, value = raju
row1 column = personal:city, timestamp = 1418275907, value = Hyderabad
row1 column = professional:designation, timestamp = 14180555,value = manager
row1 column = professional:salary, timestamp = 1418035791555,value = 50000
1 row(s) in 0.0100 seconds
The following command will update the city value of the employee
named ‘Raju’ to Delhi.
hbase(main):002:0> put 'emp','row1','personal:city','Delhi'
0 row(s) in 0.0400 seconds
Reading Data using HBase Shell
The get command and the get() method of HTable class are used to
read data from a table in HBase. Using get command, you can get
a single row of data at a time. Its syntax is as follows:
get ’<table name>’,’row1’
Example
The following example shows how to use the get command. Let
us scan the first row of the emp table.
hbase(main):012:0> get 'emp', '1'
Deleting a Specific Cell in a Table
Using the delete command, you can delete a specific cell in a table.
The syntax of delete command is as follows:
delete ‘<table name>’, ‘<row>’, ‘<column name >’, ‘<time stamp>’
Example
Here is an example to delete a specific cell. Here we are deleting
the salary.
hbase(main):006:0> delete 'emp', '1', 'personal data:city',
1417521848375
0 row(s) in 0.0060 seconds
Deleting All Cells in a Table
Using the “deleteall” command, you can delete all the cells in a
row. Given below is the syntax of deleteall command.
deleteall ‘<table name>’, ‘<row>’,
Example
Here is an example of “deleteall” command, where we are
deleting all the cells of row1 of emp table.
hbase(main):007:0> deleteall 'emp','1'
0 row(s) in 0.0240 seconds
Verify the table using the scan command. A snapshot of the table
after deleting the table is given below.
hbase(main):022:0> scan 'emp'
count
You can count the number of rows of a table using
the count command. Its syntax is as follows:
count ‘<table name>’
After deleting the first row, emp table will have two rows. Verify it
as shown below.
hbase(main):023:0> count 'emp'
2 row(s) in 0.090 seconds
⇒2
Dropping a Table using HBase Shell
Using the drop command, you can delete a table. Before dropping
a table, you have to disable it.
hbase(main):018:0> disable 'emp'
0 row(s) in 1.4580 seconds
hbase(main):019:0> drop 'emp'
0 row(s) in 0.3060 seconds
Apache Pig - Group Operator
The GROUP operator is used to group the data in one or more
relations. It collects the data having the same key.
Syntax
Given below is the syntax of the group operator.
grunt> Group_data = GROUP Relation_name BY age;
Example
Assume that we have a file named student_details.txt in the HDFS
directory /pig_data/ as shown below.
student_details.txt
001,Rajiv,Reddy,21,9848022337,Hyderabad
002,siddarth,Battacharya,22,9848022338,Kolkata
003,Rajesh,Khanna,22,9848022339,Delhi
004,Preethi,Agarwal,21,9848022330,Pune
005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar
006,Archana,Mishra,23,9848022335,Chennai
007,Komal,Nayak,24,9848022334,trivendram
008,Bharathi,Nambiayar,24,9848022333,Chennai
And we have loaded this file into Apache Pig with the relation
name student_details as shown below.
grunt> student_details = LOAD
'hdfs://localhost:9000/pig_data/student_details.txt'
USING PigStorage(',')
as (id:int, firstname:chararray, lastname:chararray,
age:int, phone:chararray, city:chararray);
Now, let us group the records/tuples in the relation by age as
shown below.
grunt> group_data = GROUP student_details by age;
Verification
Verify the relation group_data using the DUMP operator as shown
below.
grunt> Dump group_data;
Output
Then you will get output displaying the contents of the relation
named group_data as shown below. Here you can observe that the
resulting schema has two columns −
• One is age, by which we have grouped the relation.
• The other is a bag, which contains the group of tuples,
student records with the respective age.
(21,{(4,Preethi,Agarwal,21,9848022330,Pune),(1,Rajiv,Reddy,21,9848022337,Hydera bad)})
(22,{(3,Rajesh,Khanna,22,9848022339,Delhi),(2,siddarth,Battacharya,22,984802233
8,Kolkata)})
(23,{(6,Archana,Mishra,23,9848022335,Chennai),(5,Trupthi,Mohanthy,23,9848022336
,Bhuwaneshwar)})
(24,{(8,Bharathi,Nambiayar,24,9848022333,Chennai),(7,Komal,Nayak,24,9848022334,
trivendram)})
You can see the schema of the table after grouping the data using
the describe command as shown below.
grunt> Describe group_data;
group_data: {group: int,student_details: {(id: int,firstname: chararray,
lastname: chararray,age: int,phone: chararray,city: chararray)}
The JOIN operator is used to combine records from two or more
relations. While performing a join operation, we declare one (or a
group of) tuple(s) from each relation, as keys. When these keys
match, the two particular tuples are matched, else the records
are dropped. Joins can be of the following types −
• Self-join
• Inner-join
• Outer-join − left join, right join, and full join
This chapter explains with examples how to use the join operator
in Pig Latin. Assume that we have two files
namely customers.txt and orders.txt in the /pig_data/ directory of
HDFS as shown below.
customers.txt
1,Ramesh,32,Ahmedabad,2000.00
2,Khilan,25,Delhi,1500.00
3,kaushik,23,Kota,2000.00
4,Chaitali,25,Mumbai,6500.00
5,Hardik,27,Bhopal,8500.00
6,Komal,22,MP,4500.00
7,Muffy,24,Indore,10000.00
orders.txt
102,2009-10-08 00:00:00,3,3000
100,2009-10-08 00:00:00,3,1500
101,2009-11-20 00:00:00,2,1560
103,2008-05-20 00:00:00,4,2060
And we have loaded these two files into Pig with the
relations customers and orders as shown below.
grunt> customers = LOAD
'hdfs://localhost:9000/pig_data/customers.txt' USING
PigStorage(',')
as (id:int, name:chararray, age:int,
address:chararray, salary:int);
grunt> orders = LOAD
'hdfs://localhost:9000/pig_data/orders.txt' USING
PigStorage(',')
as (oid:int, date:chararray, customer_id:int,
amount:int);
Let us now perform various Join operations on these two
relations.
Self - join
Self-join is used to join a table with itself as if the table were two
relations, temporarily renaming at least one relation.
Generally, in Apache Pig, to perform self-join, we will load the
same data multiple times, under different aliases (names).
Therefore let us load the contents of the file customers.txt as two
tables as shown below.
grunt> customers1 = LOAD
'hdfs://localhost:9000/pig_data/customers.txt' USING
PigStorage(',')
as (id:int, name:chararray, age:int,
address:chararray, salary:int);
grunt> customers2 = LOAD
'hdfs://localhost:9000/pig_data/customers.txt' USING
PigStorage(',')
as (id:int, name:chararray, age:int,
address:chararray, salary:int);
Syntax
Given below is the syntax of performing self-join operation using
the JOIN operator.
grunt> Relation3_name = JOIN Relation1_name BY key, Relation2_name BY key ;
Example
Let us perform self-join operation on the relation customers, by
joining the two relations customers1 and customers2 as shown
below.
grunt> customers3 = JOIN customers1 BY id, customers2
BY id;
Verification
Verify the relation customers3 using the DUMP operator as shown
below.
grunt> Dump customers3;
Output
It will produce the following output, displaying the contents of the
relation customers.
(1,Ramesh,32,Ahmedabad,2000,1,Ramesh,32,Ahmedabad,2000)
(2,Khilan,25,Delhi,1500,2,Khilan,25,Delhi,1500)
(3,kaushik,23,Kota,2000,3,kaushik,23,Kota,2000)
(4,Chaitali,25,Mumbai,6500,4,Chaitali,25,Mumbai,6500)
(5,Hardik,27,Bhopal,8500,5,Hardik,27,Bhopal,8500)
(6,Komal,22,MP,4500,6,Komal,22,MP,4500)
(7,Muffy,24,Indore,10000,7,Muffy,24,Indore,10000)
Inner Join
Inner Join is used quite frequently; it is also referred to as equijoin.
An inner join returns rows when there is a match in both tables.
It creates a new relation by combining column values of two
relations (say A and B) based upon the join-predicate. The query
compares each row of A with each row of B to find all pairs of
rows which satisfy the join-predicate. When the join-predicate is
satisfied, the column values for each matched pair of rows of A
and B are combined into a result row.
Syntax
Here is the syntax of performing inner join operation using
the JOIN operator.
grunt> result = JOIN relation1 BY columnname, relation2 BY columnname;
Example
Let us perform inner join operation on the two
relations customers and orders as shown below.
grunt> coustomer_orders = JOIN customers BY id, orders
BY customer_id;
Verification
Verify the relation coustomer_orders using the DUMP operator as
shown below.
grunt> Dump coustomer_orders;
Output
You will get the following output that will the contents of the
relation named coustomer_orders.
(2,Khilan,25,Delhi,1500,101,2009-11-20 00:00:00,2,1560)
(3,kaushik,23,Kota,2000,100,2009-10-08 00:00:00,3,1500)
(3,kaushik,23,Kota,2000,102,2009-10-08 00:00:00,3,3000)
(4,Chaitali,25,Mumbai,6500,103,2008-05-20 00:00:00,4,2060)
Note −
Outer Join: Unlike inner join, outer join returns all the rows from at
least one of the relations. An outer join operation is carried out in
three ways −
• Left outer join
• Right outer join
• Full outer join
Left Outer Join
The left outer Join operation returns all rows from the left table,
even if there are no matches in the right relation.
Syntax
Given below is the syntax of performing left outer join operation
using the JOIN operator.
grunt> Relation3_name = JOIN Relation1_name BY id LEFT OUTER, Relation2_name BY
customer_id;
Example
Let us perform left outer join operation on the two relations
customers and orders as shown below.
grunt> outer_left = JOIN customers BY id LEFT OUTER,
orders BY customer_id;
Verification
Verify the relation outer_left using the DUMP operator as shown
below.
grunt> Dump outer_left;
Output
It will produce the following output, displaying the contents of the
relation outer_left.
(1,Ramesh,32,Ahmedabad,2000,,,,)
(2,Khilan,25,Delhi,1500,101,2009-11-20 00:00:00,2,1560)
(3,kaushik,23,Kota,2000,100,2009-10-08 00:00:00,3,1500)
(3,kaushik,23,Kota,2000,102,2009-10-08 00:00:00,3,3000)
(4,Chaitali,25,Mumbai,6500,103,2008-05-20 00:00:00,4,2060)
(5,Hardik,27,Bhopal,8500,,,,)
(6,Komal,22,MP,4500,,,,)
(7,Muffy,24,Indore,10000,,,,)
Right Outer Join
The right outer join operation returns all rows from the right table,
even if there are no matches in the left table.
Syntax
Given below is the syntax of performing right outer join operation
using the JOIN operator.
grunt> outer_right = JOIN customers BY id RIGHT, orders BY customer_id;
Example
Let us perform right outer join operation on the two
relations customers and orders as shown below.
grunt> outer_right = JOIN customers BY id RIGHT, orders
BY customer_id;
Verification
Verify the relation outer_right using the DUMP operator as shown
below.
grunt> Dump outer_right
Output
It will produce the following output, displaying the contents of the
relation outer_right.
(2,Khilan,25,Delhi,1500,101,2009-11-20 00:00:00,2,1560)
(3,kaushik,23,Kota,2000,100,2009-10-08 00:00:00,3,1500)
(3,kaushik,23,Kota,2000,102,2009-10-08 00:00:00,3,3000)
(4,Chaitali,25,Mumbai,6500,103,2008-05-20 00:00:00,4,2060)
Full Outer Join
The full outer join operation returns rows when there is a match in
one of the relations.
Syntax
Given below is the syntax of performing full outer join using
the JOIN operator.
grunt> outer_full = JOIN customers BY id FULL OUTER, orders BY customer_id;
Example
Let us perform full outer join operation on the two
relations customers and orders as shown below.
grunt> outer_full = JOIN customers BY id FULL OUTER,
orders BY customer_id;
Verification
Verify the relation outer_full using the DUMP operator as shown
below.
grun> Dump outer_full;
Output
It will produce the following output, displaying the contents of the
relation outer_full.
(1,Ramesh,32,Ahmedabad,2000,,,,)
(2,Khilan,25,Delhi,1500,101,2009-11-20 00:00:00,2,1560)
(3,kaushik,23,Kota,2000,100,2009-10-08 00:00:00,3,1500)
(3,kaushik,23,Kota,2000,102,2009-10-08 00:00:00,3,3000)
(4,Chaitali,25,Mumbai,6500,103,2008-05-20 00:00:00,4,2060)
(5,Hardik,27,Bhopal,8500,,,,)
(6,Komal,22,MP,4500,,,,)
(7,Muffy,24,Indore,10000,,,,)
The SPLIT operator is used to split a relation into two or more
relations.
Syntax
Given below is the syntax of the SPLIT operator.
grunt> SPLIT Relation1_name INTO Relation2_name IF (condition1), Relation2_name
(condition2),
Example
Assume that we have a file named student_details.txt in the HDFS
directory /pig_data/ as shown below.
student_details.txt
001,Rajiv,Reddy,21,9848022337,Hyderabad
002,siddarth,Battacharya,22,9848022338,Kolkata
003,Rajesh,Khanna,22,9848022339,Delhi
004,Preethi,Agarwal,21,9848022330,Pune
005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar
006,Archana,Mishra,23,9848022335,Chennai
007,Komal,Nayak,24,9848022334,trivendram
008,Bharathi,Nambiayar,24,9848022333,Chennai
And we have loaded this file into Pig with the relation
name student_details as shown below.
student_details = LOAD
'hdfs://localhost:9000/pig_data/student_details.txt'
USING PigStorage(',')
as (id:int, firstname:chararray, lastname:chararray,
age:int, phone:chararray, city:chararray);
Let us now split the relation into two, one listing the employees of
age less than 23, and the other listing the employees having the
age between 22 and 25.
SPLIT student_details into student_details1 if age<23,
student_details2 if (22<age and age>25);
Verification
Verify the relations student_details1 and student_details2 using
the DUMP operator as shown below.
grunt> Dump student_details1;
grunt> Dump student_details2;
Output
It will produce the following output, displaying the contents of the
relations student_details1 and student_details2 respectively.
grunt> Dump student_details1;
(1,Rajiv,Reddy,21,9848022337,Hyderabad)
(2,siddarth,Battacharya,22,9848022338,Kolkata)
(3,Rajesh,Khanna,22,9848022339,Delhi)
(4,Preethi,Agarwal,21,9848022330,Pune)
grunt> Dump student_details2;
(5,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar)
(6,Archana,Mishra,23,9848022335,Chennai)
(7,Komal,Nayak,24,9848022334,trivendram)
(8,Bharathi,Nambiayar,24,9848022333,Chennai)
The FILTER operator is used to select the required tuples from a
relation based on a condition.
Syntax
Given below is the syntax of the FILTER operator.
grunt> Relation2_name = FILTER Relation1_name BY (condition);
Example
Assume that we have a file named student_details.txt in the HDFS
directory /pig_data/ as shown below.
student_details.txt
001,Rajiv,Reddy,21,9848022337,Hyderabad
002,siddarth,Battacharya,22,9848022338,Kolkata
003,Rajesh,Khanna,22,9848022339,Delhi
004,Preethi,Agarwal,21,9848022330,Pune
005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar
006,Archana,Mishra,23,9848022335,Chennai
007,Komal,Nayak,24,9848022334,trivendram
008,Bharathi,Nambiayar,24,9848022333,Chennai
And we have loaded this file into Pig with the relation
name student_details as shown below.
grunt> student_details = LOAD
'hdfs://localhost:9000/pig_data/student_details.txt'
USING PigStorage(',')
as (id:int, firstname:chararray, lastname:chararray,
age:int, phone:chararray, city:chararray);
Let us now use the Filter operator to get the details of the
students who belong to the city Chennai.
filter_data = FILTER student_details BY city ==
'Chennai';
Verification
Verify the relation filter_data using the DUMP operator as shown
below.
grunt> Dump filter_data;
Output
It will produce the following output, displaying the contents of the
relation filter_data as follows.
(6,Archana,Mishra,23,9848022335,Chennai)
(8,Bharathi,Nambiayar,24,9848022333,Chennai)
The DISTINCT operator is used to remove redundant (duplicate)
tuples from a relation.
Syntax
Given below is the syntax of the DISTINCT operator.
grunt> Relation_name2 = DISTINCT Relatin_name1;
Example
Assume that we have a file named student_details.txt in the HDFS
directory /pig_data/ as shown below.
student_details.txt
001,Rajiv,Reddy,9848022337,Hyderabad
002,siddarth,Battacharya,9848022338,Kolkata
002,siddarth,Battacharya,9848022338,Kolkata
003,Rajesh,Khanna,9848022339,Delhi
003,Rajesh,Khanna,9848022339,Delhi
004,Preethi,Agarwal,9848022330,Pune
005,Trupthi,Mohanthy,9848022336,Bhuwaneshwar
006,Archana,Mishra,9848022335,Chennai
006,Archana,Mishra,9848022335,Chennai
And we have loaded this file into Pig with the relation
name student_details as shown below.
grunt> student_details = LOAD
'hdfs://localhost:9000/pig_data/student_details.txt'
USING PigStorage(',')
as (id:int, firstname:chararray, lastname:chararray,
phone:chararray, city:chararray);
Let us now remove the redundant (duplicate) tuples from the
relation named student_details using the DISTINCT operator, and
store it as another relation named distinct_data as shown below.
grunt> distinct_data = DISTINCT student_details;
Verification
Verify the relation distinct_data using the DUMP operator as shown
below.
grunt> Dump distinct_data;
Output
It will produce the following output, displaying the contents of the
relation distinct_data as follows.
(1,Rajiv,Reddy,9848022337,Hyderabad)
(2,siddarth,Battacharya,9848022338,Kolkata)
(3,Rajesh,Khanna,9848022339,Delhi)
(4,Preethi,Agarwal,9848022330,Pune)
(5,Trupthi,Mohanthy,9848022336,Bhuwaneshwar)
(6,Archana,Mishra,9848022335,Chennai)
The FOREACH operator is used to generate specified data
transformations based on the column data.
Syntax
Given below is the syntax of FOREACH operator.
grunt> Relation_name2 = FOREACH Relatin_name1 GENERATE (required data);
Example
Assume that we have a file named student_details.txt in the HDFS
directory /pig_data/ as shown below.
student_details.txt
001,Rajiv,Reddy,21,9848022337,Hyderabad
002,siddarth,Battacharya,22,9848022338,Kolkata
003,Rajesh,Khanna,22,9848022339,Delhi
004,Preethi,Agarwal,21,9848022330,Pune
005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar
006,Archana,Mishra,23,9848022335,Chennai
007,Komal,Nayak,24,9848022334,trivendram
008,Bharathi,Nambiayar,24,9848022333,Chennai
And we have loaded this file into Pig with the relation
name student_details as shown below.
grunt> student_details = LOAD
'hdfs://localhost:9000/pig_data/student_details.txt'
USING PigStorage(',')
as (id:int, firstname:chararray,
lastname:chararray,age:int, phone:chararray,
city:chararray);
Let us now get the id, age, and city values of each student from
the relation student_details and store it into another relation
named foreach_data using the foreach operator as shown below.
grunt> foreach_data = FOREACH student_details GENERATE
id,age,city;
Verification
Verify the relation foreach_data using the DUMP operator as shown
below.
grunt> Dump foreach_data;
Output
It will produce the following output, displaying the contents of the
relation foreach_data.
(1,21,Hyderabad)
(2,22,Kolkata)
(3,22,Delhi)
(4,21,Pune)
(5,23,Bhuwaneshwar)
(6,23,Chennai)
(7,24,trivendram)
(8,24,Chennai)
The ORDER BY operator is used to display the contents of a
relation in a sorted order based on one or more fields.
Syntax
Given below is the syntax of the ORDER BY operator.
grunt> Relation_name2 = ORDER Relatin_name1 BY (ASC|DESC);
Example
Assume that we have a file named student_details.txt in the HDFS
directory /pig_data/ as shown below.
student_details.txt
001,Rajiv,Reddy,21,9848022337,Hyderabad
002,siddarth,Battacharya,22,9848022338,Kolkata
003,Rajesh,Khanna,22,9848022339,Delhi
004,Preethi,Agarwal,21,9848022330,Pune
005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar
006,Archana,Mishra,23,9848022335,Chennai
007,Komal,Nayak,24,9848022334,trivendram
008,Bharathi,Nambiayar,24,9848022333,Chennai
And we have loaded this file into Pig with the relation
name student_details as shown below.
grunt> student_details = LOAD
'hdfs://localhost:9000/pig_data/student_details.txt'
USING PigStorage(',')
as (id:int, firstname:chararray,
lastname:chararray,age:int, phone:chararray,
city:chararray);
Let us now sort the relation in a descending order based on the
age of the student and store it into another relation
named order_by_data using the ORDER BY operator as shown
below.
grunt> order_by_data = ORDER student_details BY age
DESC;
Verification
Verify the relation order_by_data using the DUMP operator as
shown below.
grunt> Dump order_by_data;
Output
It will produce the following output, displaying the contents of the
relation order_by_data.
(8,Bharathi,Nambiayar,24,9848022333,Chennai)
(7,Komal,Nayak,24,9848022334,trivendram)
(6,Archana,Mishra,23,9848022335,Chennai)
(5,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar)
(3,Rajesh,Khanna,22,9848022339,Delhi)
(2,siddarth,Battacharya,22,9848022338,Kolkata)
(4,Preethi,Agarwal,21,9848022330,Pune)
(1,Rajiv,Reddy,21,9848022337,Hyderabad)
The LIMIT operator is used to get a limited number of tuples
from a relation.
Syntax
Given below is the syntax of the LIMIT operator.
grunt> Result = LIMIT Relation_name required number of tuples;
Example
Assume that we have a file named student_details.txt in the HDFS
directory /pig_data/ as shown below.
student_details.txt
001,Rajiv,Reddy,21,9848022337,Hyderabad
002,siddarth,Battacharya,22,9848022338,Kolkata
003,Rajesh,Khanna,22,9848022339,Delhi
004,Preethi,Agarwal,21,9848022330,Pune
005,Trupthi,Mohanthy,23,9848022336,Bhuwaneshwar
006,Archana,Mishra,23,9848022335,Chennai
007,Komal,Nayak,24,9848022334,trivendram
008,Bharathi,Nambiayar,24,9848022333,Chennai
And we have loaded this file into Pig with the relation
name student_details as shown below.
grunt> student_details = LOAD
'hdfs://localhost:9000/pig_data/student_details.txt'
USING PigStorage(',')
as (id:int, firstname:chararray,
lastname:chararray,age:int, phone:chararray,
city:chararray);
Now, let’s sort the relation in descending order based on the age
of the student and store it into another relation
named limit_data using the ORDER BY operator as shown below.
grunt> limit_data = LIMIT student_details 4;
Verification
Verify the relation limit_data using the DUMP operator as shown
below.
grunt> Dump limit_data;
Output
It will produce the following output, displaying the contents of the
relation limit_data as follows.
(1,Rajiv,Reddy,21,9848022337,Hyderabad)
(2,siddarth,Battacharya,22,9848022338,Kolkata)
(3,Rajesh,Khanna,22,9848022339,Delhi)
(4,Preethi,Agarwal,21,9848022330,Pune)
Eval Functions
Given below is the list of eval functions provided by Apache Pig.
S.N. Function & Description
AVG()
1
To compute the average of the numerical values within a bag.
BagToString()
2
To concatenate the elements of a bag into a string. While concatenating, we
can place a delimiter between these values (optional).
CONCAT()
3
To concatenate two or more expressions of same type.
COUNT()
4
To get the number of elements in a bag, while counting the number of tuples
in a bag.
COUNT_STAR()
5
It is similar to the COUNT() function. It is used to get the number of
elements in a bag.
DIFF()
6
To compare two bags (fields) in a tuple.
IsEmpty()
7
To check if a bag or map is empty.
MAX()
8
To calculate the highest value for a column (numeric values or chararrays) in
a single-column bag.
MIN()
9
To get the minimum (lowest) value (numeric or chararray) for a certain
column in a single-column bag.
PluckTuple()
10
Using the Pig Latin PluckTuple() function, we can define a string Prefix and
filter the columns in a relation that begin with the given prefix.
SIZE()
11
To compute the number of elements based on any Pig data type.
SUBTRACT()
12
To subtract two bags. It takes two bags as inputs and returns a bag which
contains the tuples of the first bag that are not in the second bag.
SUM()
13
To get the total of the numeric values of a column in a single-column bag.
TOKENIZE()
14
To split a string (which contains a group of words) in a single tuple and
return a bag which contains the output of the split operation.
