{"id":13958,"date":"2018-04-19T12:24:52","date_gmt":"2018-04-19T12:24:52","guid":{"rendered":"https:\/\/data-flair.training\/blogs\/?p=13958"},"modified":"2018-04-19T12:24:52","modified_gmt":"2018-04-19T12:24:52","slug":"apache-pig-built-in-functions","status":"publish","type":"post","link":"https:\/\/data-flair.training\/blogs\/apache-pig-built-in-functions\/","title":{"rendered":"Apache Pig Built in Functions Cheat Sheet"},"content":{"rendered":"

In this article “Apache Pig Built in Functions”, we will discuss all the Apache Pig<\/strong> Built-in Functions in detail. It includes eval, load\/store, math, bag and tuple functions and many more. Also, we will see their syntax along with their functions and descriptions to understand them well.<\/span><\/p>\n

So, let’s start Pig Built in Functions.<\/p>\n

Pig Functions<\/span><\/h2>\n

There is a huge set of Apache Pig Built in Functions available. Such as the eval, load\/store, math, string, date and time, bag and tuple functions. Basically, there are two main properties which differentiate built in functions from user-defined functions (UDFs) such as:<\/span><\/p>\n

    \n
  • We do not need to register built in functions since Pig knows where they are. <\/span><\/li>\n
  • Also, we do not need to qualify built in functions, while using them, because again Pig knows where to find them.<\/span><\/li>\n<\/ul>\n

    List of Apache Pig Built in Functions<\/span><\/h2>\n

    Let\u2019s discuss various Apache Pig Built in Functions namely eval, load, store, math, string, bag, and tuple, one by one in depth. <\/span><\/p>\n

    a. Eval Functions<\/span><\/h3>\n

    Eval Functions is the first types of Pig Built in Functions.\u00a0Here are the Pig Eval functions, offered by Apache Pig.<\/span>
    \ni. AVG()<\/strong><\/p>\n

      \n
    • AVG Syntax<\/strong><\/li>\n<\/ul>\n

      AVG(expression)<\/span>
      \nWe use AVG(), to compute the average of the numerical values within a bag.<\/span><\/p>\n

        \n
      • AVG Example<\/strong><\/li>\n<\/ul>\n

        In this example, the average GPA for each Employee is computed
        \nA = LOAD ‘Employee.txt’ AS (name:chararray, term:chararray, gpa:float);
        \nDUMP A;
        \n(johny,fl,3.9F)
        \n(johny,wt,3.7F)
        \n(johny,sp,4.0F)
        \n(johny,sm,3.8F)
        \n(Mariya,fl,3.8F)
        \n(Mariya,wt,3.9F)
        \n(Mariya,sp,4.0F)
        \n(Mariya,sm,4.0F)
        \nB = GROUP A BY name;
        \nDUMP B;
        \n(johny,{(johny,fl,3.9F),(johny,wt,3.7F),(johny,sp,4.0F),(johny,sm,3.8F)})
        \n(Mariya,{(Mariya,fl,3.8F),(Mariya,wt,3.9F),(Mariya,sp,4.0F),(Mariya,sm,4.0F)})
        \nC = FOREACH B GENERATE A.name, AVG(A.gpa);
        \nDUMP C;
        \n({(johny),(johny),(johny),(johny)},3.850000023841858)
        \n({(Mariya),(Mariya),(Mariya),(Mariya)},3.925000011920929)<\/p>\n

        ii. BagToString()<\/strong>
        \nThis function is used to concatenate the elements of a bag into a string. We can place a delimiter between these values (optional) while concatenating.<\/span><\/p>\n

        iii. CONCAT()<\/strong><\/p>\n

          \n
        • The syntax of CONCAT()<\/strong><\/li>\n<\/ul>\n

          CONCAT (expression, expression)<\/span>
          \nWe use this Pig Function to concatenate two or more expressions of the same type.<\/span><\/p>\n

            \n
          • Example of\u00a0CONCAT()<\/strong><\/li>\n<\/ul>\n

            In this example, fields f1, an underscore string literal, f2 and f3 are concatenated.
            \nX = LOAD ‘data’ as (f1:chararray, f2:chararray, f3:chararray);
            \nDUMP X;
            \n(apache,open,source)
            \n(hadoop,map,reduce)
            \n(pig,pig,latin)
            \nY = FOREACH X GENERATE CONCAT(f1, ‘_’, f2,f3);
            \nDUMP Y;
            \n(apache_opensource)
            \n(hadoop_mapreduce)
            \n(pig_piglatin)<\/p>\n

            iv. COUNT()<\/strong><\/p>\n

              \n
            • The syntax of COUNT()<\/strong>\u00a0<\/span><\/li>\n<\/ul>\n

              COUNT(expression)<\/span>
              \nWhile counting the number of tuples in a bag, we use it to get the number of elements in a bag.<\/span><\/p>\n

                \n
              • Example of COUNT()<\/strong><\/li>\n<\/ul>\n

                In this example, we count the tuples in the bag:
                \nX = LOAD ‘data’ AS (f1:int,f2:int,f3:int);
                \nDUMP X;
                \n(1,2,3)
                \n(4,2,1)
                \n(8,3,4)
                \n(4,3,3)
                \n(7,2,5)
                \n(8,4,3)
                \nY = GROUP X BY f1;
                \nDUMP B;
                \n(1,{(1,2,3)})
                \n(4,{(4,2,1),(4,3,3)})
                \n(7,{(7,2,5)})
                \n(8,{(8,3,4),(8,4,3)})
                \nA = FOREACH Y GENERATE COUNT(X);
                \nDUMP A;
                \n(1L)
                \n(2L)
                \n(1L)
                \n(2L)<\/p>\n

                v. COUNT_STAR()<\/strong><\/p>\n

                  \n
                • The syntax of COUNT_STAR()<\/strong><\/li>\n<\/ul>\n

                  COUNT_STAR(expression)<\/span>
                  \nWe can say it is similar to the COUNT() function. To get the number of elements in a bag, we use it.<\/span><\/p>\n

                    \n
                  • Example of COUNT_STAR()<\/strong><\/li>\n<\/ul>\n

                    To count the tuples in a bag.
                    \nA = FOREACH Y GENERATE COUNT_STAR(X);
                    \nvi. DIFF()<\/strong><\/p>\n

                      \n
                    • The syntax of DIFF()<\/strong><\/li>\n<\/ul>\n

                      DIFF (expression, expression)<\/span>
                      \nIn order to compare two bags (fields) in a tuple.<\/span><\/p>\n

                        \n
                      • Example of DIFF()<\/strong><\/li>\n<\/ul>\n

                        Here, compares the tuples in two bags.
                        \nA = LOAD ‘bag_data’ AS (B1:bag{T1:tuple(t1:int,t2:int)},B2:bag{T2:tuple(f1:int,f2:int)});
                        \nDUMP A;
                        \n({(8,9),(0,1)},{(8,9),(1,1)})
                        \n({(2,3),(4,5)},{(2,3),(4,5)})
                        \n({(6,7),(3,7)},{(2,2),(3,7)})
                        \nDESCRIBE A;
                        \na: {B1: {T1: (t1: int,t2: int)},B2: {T2: (f1: int,f2: int)}}
                        \nX = FOREACH A GENERATE DIFF(B1,B2);
                        \ngrunt> dump x;
                        \n({(0,1),(1,1)})
                        \n({})
                        \n({(6,7),(2,2)})<\/p>\n

                        vii. IsEmpty()<\/strong><\/p>\n

                          \n
                        • The Syntax of IsEmpty ()<\/strong><\/li>\n<\/ul>\n

                          IsEmpty(expression)<\/span>
                          \nWe use this Apache Pig function to check if a bag or map is empty.<\/span><\/p>\n

                            \n
                          • Example of IsEmpty ()<\/strong><\/li>\n<\/ul>\n

                            Here, all Employees with an SSN but no name are located.
                            \nSSN = load ‘ssn.txt’ using PigStorage() as (ssn:long);
                            \nSSN_NAME = load ‘Employees.txt’ using PigStorage() as (ssn:long, name:chararray);
                            \n\/* do a cogroup of SSN with SSN_Name *\/
                            \nX = COGROUP SSN by ssn, SSN_NAME by ssn;
                            \n\/* Keep ssn’s for which there is no name only *\/
                            \nY = filter X by IsEmpty(SSN_NAME);<\/p>\n

                            viii. MAX()<\/strong><\/p>\n

                              \n
                            • The Syntax of MAX()<\/strong><\/li>\n<\/ul>\n

                              MAX(expression)<\/span>
                              \nBasically, to calculate the highest value for a column (numeric values or chararrays) in a single-column bag.<\/span><\/p>\n

                                \n
                              • Example of\u00a0<\/strong>MAX()<\/strong><\/li>\n<\/ul>\n

                                A = LOAD ‘Employee’ AS (name:chararray, session:chararray, gpa:float);
                                \nDUMP A;
                                \n(Johny,fl,3.9F)
                                \n(Johny,wt,3.7F)
                                \n(Johny,sp,4.0F)
                                \n(Johny,sm,3.8F)
                                \n(Mariya,fl,3.8F)
                                \n(Mariya,wt,3.9F)
                                \n(Mariya,sp,4.0F)
                                \n(Mariya,sm,4.0F)
                                \nB = GROUP A BY name;
                                \nDUMP B;
                                \n(Johny,{(Johny,fl,3.9F),(Johny,wt,3.7F),(Johny,sp,4.0F),(Johny,sm,3.8F)})
                                \n(Mariya,{(Mariya,fl,3.8F),(Mariya,wt,3.9F),(Mariya,sp,4.0F),(Mariya,sm,4.0F)})
                                \nX = FOREACH B GENERATE group, MAX(A.gpa);
                                \nDUMP X;
                                \n(Johny,4.0F)
                                \n(Mariya,4.0F)<\/p>\n

                                ix. MIN()<\/strong><\/p>\n

                                  \n
                                • The Syntax of MIN()<\/strong><\/li>\n<\/ul>\n

                                  MIN(expression)<\/span>
                                  \nIn order to get the minimum (lowest) value (numeric or chararray) for a certain column in a single-column bag.<\/span><\/p>\n

                                    \n
                                  • Example of MIN()<\/strong><\/li>\n<\/ul>\n

                                    A = LOAD ‘Employee’ AS (name:chararray, session:chararray, gpa:float);
                                    \nDUMP A;
                                    \n(Johny,fl,3.9F)
                                    \n(Johny,wt,3.7F)
                                    \n(Johny,sp,4.0F)
                                    \n(Johny,sm,3.8F)
                                    \n(Mariya,fl,3.8F)
                                    \n(Mariya,wt,3.9F)
                                    \n(Mariya,sp,4.0F)
                                    \n(Mariya,sm,4.0F)
                                    \nB = GROUP A BY name;
                                    \nDUMP B;
                                    \n(Johny,{(Johny,fl,3.9F),(Johny,wt,3.7F),(Johny,sp,4.0F),(Johny,sm,3.8F)})
                                    \n(Mariya,{(Mariya,fl,3.8F),(Mariya,wt,3.9F),(Mariya,sp,4.0F),(Mariya,sm,4.0F)})
                                    \nX = FOREACH B GENERATE group, MIN(A.gpa);
                                    \nDUMP X;
                                    \n(Johny,3.7F)
                                    \n(Mariya,3.8F)<\/p>\n

                                    x. PluckTuple()<\/strong>
                                    \nWe can define a string prefix and filter the columns in a relation that begin with the given prefix, using the Pig Latin PluckTuple() function.<\/span><\/p>\n

                                      \n
                                    • Example of PluckTuple<\/strong><\/li>\n<\/ul>\n

                                      a = load ‘a’ as (x, y);
                                      \nb = load ‘b’ as (x, y);
                                      \nc = join a by x, b by x;
                                      \nDEFINE pluck PluckTuple(‘a::’);
                                      \nd = foreach c generate FLATTEN(pluck(*));
                                      \ndescribe c;
                                      \nc: {a::x: bytearray,a::y: bytearray,b::x: bytearray,b::y: bytearray}
                                      \ndescribe d;
                                      \nd: {plucked::a::x: bytearray,plucked::a::y: bytearray}
                                      \nDEFINE pluckNegative PluckTuple(‘a::’,’false’);
                                      \nd = foreach c generate FLATTEN(pluckNegative(*));
                                      \ndescribe d;
                                      \nd: {plucked::b::x: bytearray,plucked::b::y: bytearray}<\/p>\n

                                      xi. SIZE()<\/strong><\/p>\n

                                        \n
                                      • The Syntax of SIZE()<\/strong><\/li>\n<\/ul>\n

                                        SIZE(expression)<\/span>
                                        \nWe use this Pig Function in order to compute the number of elements based on any Pig data type.<\/span><\/p>\n

                                          \n
                                        • Example of SIZE()<\/strong><\/li>\n<\/ul>\n

                                          Here, we are computing the number of characters in the first field
                                          \nA = LOAD ‘data’ as (f1:chararray, f2:chararray, f3:chararray);
                                          \n(apache,open,source)
                                          \n(hadoop,map,reduce)
                                          \n(pig,pig,latin)
                                          \nX = FOREACH A GENERATE SIZE(f1);
                                          \nDUMP X;
                                          \n(6L)
                                          \n(6L)
                                          \n(3L)<\/p>\n

                                          xii. SUBTRACT()<\/strong>
                                          \nBasically, to subtract two bags. As a process, it takes two bags as inputs. Then returns a bag which contains the tuples of the first bag that are not in the second bag.<\/span><\/p>\n

                                            \n
                                          • Example of\u00a0SUBTRACT()<\/strong><\/li>\n<\/ul>\n

                                            It creates a new bag composed of B1 elements that are not in B2.
                                            \nA = LOAD ‘bag_data’ AS (B1:bag{T1:tuple(t1:int,t2:int)},B2:bag{T2:tuple(f1:int,f2:int)});
                                            \nDUMP A;
                                            \n({(8,9),(0,1),(1,2)},{(8,9),(1,1)})
                                            \n({(2,3),(4,5)},{(2,3),(4,5)})
                                            \n({(6,7),(3,7),(3,7)},{(2,2),(3,7)})
                                            \nDESCRIBE A;
                                            \nA: {B1: {T1: (t1: int,t2: int)},B2: {T2: (f1: int,f2: int)}}
                                            \nX = FOREACH A GENERATE SUBTRACT(B1,B2);
                                            \nDUMP X;
                                            \n({(0,1),(1,2)})
                                            \n({})
                                            \n({(6,7)})<\/p>\n

                                            xiii. SUM()<\/strong><\/p>\n

                                              \n
                                            • Syntax of SUM()<\/strong><\/li>\n<\/ul>\n

                                              SUM(expression)<\/span>
                                              \nThis Function in Pig is to get the total of the numeric values of a column in a single-column bag.<\/span><\/p>\n

                                                \n
                                              • Example of SUM()<\/strong><\/li>\n<\/ul>\n

                                                It creates a new bag composed of B1 elements that are not in B2.
                                                \nA = LOAD ‘bag_data’ AS (B1:bag{T1:tuple(t1:int,t2:int)},B2:bag{T2:tuple(f1:int,f2:int)});
                                                \nDUMP A;
                                                \n({(8,9),(0,1),(1,2)},{(8,9),(1,1)})
                                                \n({(2,3),(4,5)},{(2,3),(4,5)})
                                                \n({(6,7),(3,7),(3,7)},{(2,2),(3,7)})
                                                \nDESCRIBE A;
                                                \nA: {B1: {T1: (t1: int,t2: int)},B2: {T2: (f1: int,f2: int)}}
                                                \nX = FOREACH A GENERATE SUBTRACT(B1,B2);
                                                \nDUMP X;
                                                \n({(0,1),(1,2)})
                                                \n({})
                                                \n({(6,7)})
                                                \nB = GROUP A BY owner;
                                                \nDUMP B;
                                                \n(Alice,{(Alice,turtle,1),(Alice,goldfish,5),(Alice,cat,2)})
                                                \n(Bob,{(Bob,dog,2),(Bob,cat,2)})
                                                \nX = FOREACH B GENERATE group, SUM(A.pet_num);
                                                \nDUMP X;
                                                \n(Alice,8L)
                                                \n(Bob,4L)<\/p>\n

                                                xiv. TOKENIZE()<\/strong><\/p>\n

                                                  \n
                                                • Syntax of TOKENIZE()<\/strong><\/li>\n<\/ul>\n

                                                  TOKENIZE(expression)<\/span>
                                                  \nFor splitting a string (which contains a group of words) in a single tuple. Then return a bag which contains the output of the split operation.<\/span><\/p>\n

                                                    \n
                                                  • Example of TOKENIZE()<\/strong><\/li>\n<\/ul>\n

                                                    The strings in each row are split.
                                                    \nA = LOAD ‘data’ AS (f1:chararray);
                                                    \nDUMP A;
                                                    \n(It is the first string.)
                                                    \n(It is the second string.)
                                                    \n(It is the third string.)
                                                    \nX = FOREACH A GENERATE TOKENIZE(f1);
                                                    \nDUMP X;
                                                    \n({(It),(is),(the),(first),(string.)})
                                                    \n({(It),(is),(the),(second),(string.)})
                                                    \n({(It),(is),(the),(third),(string.)})
                                                    \nHere, a field delimiter is specified.
                                                    \n{code}
                                                    \nA = LOAD ‘data’ AS (f1:chararray);
                                                    \nB = FOREACH A GENERATE TOKENIZE (f1,’||’);
                                                    \nDUMP B;
                                                    \n{code}<\/p>\n

                                                    b. Load and Store Functions<\/span><\/h3>\n

                                                    To determine, how data goes into Pig and comes out of Pig we use Load\/store functions – Pig Built in Functions. Also, we can write your own load\/store functions. There is a set of built-in load\/store functions such as:<\/span><\/p>\n

                                                    i. PigStorage()<\/strong><\/p>\n

                                                      \n
                                                    • Syntax of PigStorage()<\/strong><\/li>\n<\/ul>\n

                                                      PigStorage(field_delimiter)<\/span>
                                                      \nIn order to load and store structured files.<\/span><\/p>\n

                                                        \n
                                                      • Example of\u00a0PigStorage()<\/strong><\/li>\n<\/ul>\n

                                                        Here, PigStorage expects input.txt to contain tab-separated fields as well as newline-separated records. So, statements are equivalent.
                                                        \nA = LOAD ‘Employee’ USING PigStorage(‘\\t’) AS (name: chararray, age:int, gpa: float);
                                                        \nA = LOAD ‘Employee’ AS (name: chararray, age:int, gpa: float);
                                                        \nAlso, here, PigStorage stores the contents of X into files along with fields that are delimited with an asterisk ( * ). And, the STORE statement specifies that the files will be located in a directory named output and that the files will be named part-nnnnn (for example, part-00000).
                                                        \nSTORE X INTO ‘output’ USING PigStorage(‘*’);
                                                        \nHere, PigStorage loads data with complex data type, a bag of map and double.
                                                        \na = load ‘1.txt’ as (a0:{t:(m:map[int],d:double)});
                                                        \n{([foo#1,bar#2],34.0),([white#3,yellow#4],45.0)} : valid
                                                        \n{([foo#badint],baddouble)} : conversion fail for badint\/baddouble, get {([foo#],)}
                                                        \n{} : valid, empty bag<\/p>\n

                                                        ii. TextLoader()<\/strong><\/p>\n

                                                          \n
                                                        • TextLoader() Syntax\u00a0<\/strong><\/li>\n<\/ul>\n

                                                          TextLoader()<\/span>
                                                          \nThis Pig Function is used for loading unstructured data into Pig.<\/span><\/p>\n

                                                            \n
                                                          • Example of\u00a0TextLoader()<\/strong><\/li>\n<\/ul>\n

                                                            Here, TextLoader is used with the LOAD function.
                                                            \nA = LOAD ‘data’ USING TextLoader();<\/p>\n

                                                            iii. BinStorage()<\/strong><\/p>\n

                                                              \n
                                                            • BinStorage() Syntax\u00a0<\/strong><\/li>\n<\/ul>\n

                                                              BinStorage()
                                                              \n<\/span>
                                                              \nBy using machine-readable format, for loading and storing data into Pig.<\/span><\/p>\n

                                                                \n
                                                              • Example of BinStorage()<\/strong><\/li>\n<\/ul>\n

                                                                Here BinStorage is used with the LOAD and STORE functions.
                                                                \nA = LOAD ‘data’ USING BinStorage();
                                                                \nSTORE X into ‘output’ USING BinStorage();
                                                                \nHere BinStorage is used to load multiple locations.
                                                                \nA = LOAD ‘input1.bin, input2.bin’ USING BinStorage();
                                                                \nraw = load ‘sampledata’ using BinStorage() as (col1,col2, col3);
                                                                \n–filter out null columns
                                                                \nA = filter raw by col1#’bcookie’ is not null;
                                                                \nB = foreach A generate col1#’bcookie’ as reqcolumn;
                                                                \ndescribe B;
                                                                \n–B: {regcolumn: bytearray}
                                                                \nX = limit B 5;
                                                                \ndump X;
                                                                \n(36co9b55onr8s)
                                                                \n(36co9b55onr8s)
                                                                \n(36hilul5oo1q1)
                                                                \n(36hilul5oo1q1)
                                                                \n(36l4cj15ooa8a)
                                                                \nB = foreach A generate (chararray)col1#’bcookie’ as convertedcol;
                                                                \ndescribe B;
                                                                \n–B: {convertedcol: chararray}
                                                                \nX = limit B 5;
                                                                \ndump X;
                                                                \n()
                                                                \n()
                                                                \n()
                                                                \n()
                                                                \n()<\/p>\n

                                                                iv. Handling Compression<\/strong>
                                                                \n We can load and store compressed data in Pig Latin.<\/span><\/p>\n

                                                                c. Bag and Tuple Functions<\/span><\/h3>\n

                                                                Here is the list of Bag and Tuple – Pig Built in functions. Such as:<\/span><\/p>\n

                                                                i. TOBAG()<\/strong><\/p>\n

                                                                  \n
                                                                • Syntax of TOBAG()<\/strong><\/li>\n<\/ul>\n

                                                                  TOBAG(expression [, expression …])<\/span>
                                                                  \nThis Pig Built in function is used in order to convert two or more expressions into a bag.<\/span><\/p>\n

                                                                    \n
                                                                  • Example of\u00a0TOBAG()<\/strong><\/li>\n<\/ul>\n

                                                                    Here, fields f1 and f3 are converted to tuples that are then placed in a bag.
                                                                    \na = LOAD ‘Employee’ AS (f1:chararray, f2:int, f3:float);
                                                                    \nDUMP a;
                                                                    \n(Johny,18,4.0)
                                                                    \n(Mariya,19,3.8)
                                                                    \n(Billy,20,3.9)
                                                                    \n(joey,18,3.8)
                                                                    \nb = FOREACH a GENERATE TOBAG(f1,f3);
                                                                    \nDUMP b;
                                                                    \n({(Johny),(4.0)})
                                                                    \n({(Mariya),(3.8)})
                                                                    \n({(Billy),(3.9)})
                                                                    \n({(joey),(3.8)})<\/p>\n

                                                                    ii. TOP()<\/strong><\/p>\n

                                                                      \n
                                                                    • The syntax of Top()<\/strong><\/li>\n<\/ul>\n

                                                                      TOP(topN,column,relation)<\/span>
                                                                      \nForgetting the top N tuples of a relation.<\/span><\/p>\n

                                                                        \n
                                                                      • Example of TOP()<\/strong><\/li>\n<\/ul>\n

                                                                        Here the top 10 occurrences are returned.
                                                                        \nDEFINE asc TOP(‘ASC’); — ascending order
                                                                        \nDEFINE desc TOP(‘DESC’); — descending order
                                                                        \nA = LOAD ‘data’ as (first: chararray, second: chararray);
                                                                        \nB = GROUP A BY (first, second);
                                                                        \nC = FOREACH B generate FLATTEN(group), COUNT(A) as count;
                                                                        \nD = GROUP C BY first; — again group by first
                                                                        \ntopResults = FOREACH D {
                                                                        \nresult = asc(10, 1, C); — and retain top 10 (in ascending order) occurrences of ‘second’ in first
                                                                        \nGENERATE FLATTEN(result);
                                                                        \n}
                                                                        \nbottomResults = FOREACH D {
                                                                        \nresult = desc(10, 1, C); — and retain top 10 (in descending order) occurrences of ‘second’ in first
                                                                        \nGENERATE FLATTEN(result);
                                                                        \n}<\/p>\n

                                                                        iii. TOTUPLE()<\/strong><\/p>\n

                                                                          \n
                                                                        • The Syntax of TOTUPLE()<\/strong><\/li>\n<\/ul>\n

                                                                          TOTUPLE(expression [, expression …])<\/span>
                                                                          \nIn order to convert one or more expressions into a tuple.<\/span><\/p>\n

                                                                            \n
                                                                          • Example of TOTUPLE()<\/strong><\/li>\n<\/ul>\n

                                                                            Here, fields f1, f2 and f3 are converted to a tuple.
                                                                            \na = LOAD ‘Employee’ AS (f1:chararray, f2:int, f3:float);
                                                                            \nDUMP a;
                                                                            \n(Johny,18,4.0)
                                                                            \n(Mariya,19,3.8)
                                                                            \n(Billy,20,3.9)
                                                                            \n(joey,18,3.8)
                                                                            \nb = FOREACH a GENERATE TOTUPLE(f1,f2,f3);
                                                                            \nDUMP b;
                                                                            \n((Johny,18,4.0))
                                                                            \n((Mariya,19,3.8))
                                                                            \n((Billy,20,3.9))
                                                                            \n((joey,18,3.8))<\/p>\n

                                                                            iv. TOMAP()<\/strong>
                                                                            \nForgetting to convert the key-value pairs into a Map.<\/span><\/p>\n

                                                                              \n
                                                                            • Example of TOMAP()<\/strong><\/li>\n<\/ul>\n

                                                                              Here, Employee names (type chararray) and Employee GPAs (type float) are used to create three maps.
                                                                              \nA = load ‘Employees’ as (name:chararray, age:int, gpa:float);
                                                                              \nB = foreach A generate TOMAP(name, gpa);
                                                                              \nstore B into ‘results’;
                                                                              \nInput (Employees)
                                                                              \njoey smith 20 3.5
                                                                              \namy chen 22 3.2
                                                                              \nleo allen 18 2.1
                                                                              \nOutput (results)
                                                                              \n[joey smith#3.5]
                                                                              \n[amy chen#3.2]
                                                                              \n[leo allen#2.1]<\/p>\n

                                                                              d. String Functions<\/span><\/h3>\n

                                                                              Here, is the list of String – Pig Built in functions. Such as:<\/span><\/p>\n

                                                                              i. ENDSWITH(string, testAgainst)<\/strong>
                                                                              \nFor verifying whether a given string ends with a particular substring.<\/span><\/p>\n

                                                                              ii. STARTSWITH(string, substring)<\/strong>
                                                                              \nThis Pig Function verifies whether the first string starts with the second, after accepting two string parameters.<\/span><\/p>\n

                                                                              iii. SUBSTRING(string, startIndex, stopIndex)<\/strong><\/p>\n

                                                                                \n
                                                                              • Syntax<\/span><\/li>\n<\/ul>\n

                                                                                SUBSTRING(string, startIndex, stopIndex)<\/span>
                                                                                \nIt returns a substring from a given string.<\/span><\/p>\n

                                                                                iv. EqualsIgnoreCase(string1, string2)<\/strong>
                                                                                \nIn order to compare two strings ignoring the case.<\/span><\/p>\n

                                                                                v. INDEXOF(string, \u2018character\u2019, startIndex)<\/strong><\/p>\n

                                                                                  \n
                                                                                • Syntax<\/span><\/li>\n<\/ul>\n

                                                                                  INDEXOF(string, ‘character’, startIndex)<\/span>
                                                                                  \nIt returns the first occurrence of a character in a string, searching forward from a start index.<\/span><\/p>\n

                                                                                  vi. LAST_INDEX_OF(expression)<\/strong><\/p>\n

                                                                                    \n
                                                                                  • Syntax<\/span><\/li>\n<\/ul>\n

                                                                                    LAST_INDEX_OF(expression)<\/span>
                                                                                    \nTo return the index of the last occurrence of a character in a string, searching backward from a start index.<\/span><\/p>\n

                                                                                    vi. LCFIRST(expression)<\/strong><\/p>\n

                                                                                      \n
                                                                                    • Syntax<\/span><\/li>\n<\/ul>\n

                                                                                      LCFIRST(expression)<\/span>
                                                                                      \nThis Pig Function is used for conversion of the first character in a string to lowercase.<\/span><\/p>\n

                                                                                      vii. UCFIRST(expression)<\/strong><\/p>\n

                                                                                        \n
                                                                                      • Syntax<\/span><\/li>\n<\/ul>\n

                                                                                        UCFIRST(expression)<\/span>
                                                                                        \nIt returns a string with the first character converted to uppercase.<\/span><\/p>\n

                                                                                        viii. UPPER(expression)<\/strong><\/p>\n

                                                                                          \n
                                                                                        • Syntax<\/span><\/li>\n<\/ul>\n

                                                                                          UPPER(expression)<\/span>
                                                                                          \nIn order to get a string converted to upper case.<\/span><\/p>\n

                                                                                          ix. LOWER(expression)<\/strong><\/p>\n

                                                                                            \n
                                                                                          • Syntax<\/span><\/li>\n<\/ul>\n

                                                                                            LOWER(expression)<\/span>
                                                                                            \nThis function in Pig converts all characters in a string to lower case.<\/span><\/p>\n

                                                                                            x. REPLACE(string, \u2018oldChar\u2019, \u2018newChar\u2019);<\/strong><\/p>\n

                                                                                              \n
                                                                                            • Syntax<\/span><\/li>\n<\/ul>\n

                                                                                              REPLACE(string, ‘oldChar’, ‘newChar’);<\/span>
                                                                                              \nFor replacing existing characters in a string with new characters.<\/span><\/p>\n

                                                                                              xi. STRSPLIT(string, regex, limit)<\/strong><\/p>\n

                                                                                                \n
                                                                                              • Syntax<\/span><\/li>\n<\/ul>\n

                                                                                                STRSPLIT(string, regex, limit)<\/span>
                                                                                                \nIn order to split a string around matches of a given regular expression.<\/span><\/p>\n

                                                                                                xii. STRSPLITTOBAG(string, regex, limit)<\/strong>
                                                                                                \nIt splits the string by given delimiter and returns the result in a bag.<\/span><\/p>\n

                                                                                                xiii. TRIM(expression)<\/strong><\/p>\n

                                                                                                  \n
                                                                                                • Syntax<\/span><\/li>\n<\/ul>\n

                                                                                                  TRIM(expression)<\/span>
                                                                                                  \nThis Pig Built in Function is used to return a copy of a string with leading and trailing whitespaces removed.<\/span><\/p>\n

                                                                                                  xiv. LTRIM(expression)<\/strong>
                                                                                                  \nIt returns a copy of a string with leading whitespaces removed.<\/span><\/p>\n

                                                                                                  xv. RTRIM(expression)<\/strong>
                                                                                                  \nFor returning a copy of a string with trailing whitespaces removed.<\/span><\/p>\n

                                                                                                  e. Date and Time Functions<\/span><\/h3>\n

                                                                                                  Here is the list of Date and Time – Pig Built in functions. <\/span><\/p>\n

                                                                                                  i. ToDate(milliseconds)<\/strong>
                                                                                                  \nAccording to the given parameters, it returns a date-time object. There are more alternative for this functions. Such as ToDate(iosstring), ToDate(userstring, format), ToDate(userstring, format, timezone)<\/span><\/p>\n

                                                                                                  ii. CurrentTime()<\/strong>
                                                                                                  \nIt returns the date-time object of the current time.<\/span><\/p>\n

                                                                                                  iii. GetDay(datetime)<\/strong>
                                                                                                  \nTo get the day of a month as a return from the date-time object, we use it.<\/span><\/p>\n

                                                                                                  iv. GetHour(datetime)<\/strong>
                                                                                                  \n GetHour returns the hour of a day from the date-time object.<\/span><\/p>\n

                                                                                                  v. GetMilliSecond(datetime)<\/strong>
                                                                                                  \nIt returns the millisecond of a second from the date-time object.<\/span><\/p>\n

                                                                                                  vi. GetMinute(datetime)<\/strong>
                                                                                                  \nTo get the minute of an hour in return from the date-time object, we use it.<\/span><\/p>\n

                                                                                                  vii. GetMonth(datetime)<\/strong>
                                                                                                  \nGetMonth returns the month of a year from the date-time object.<\/span><\/p>\n

                                                                                                  viii. GetSecond(datetime)<\/strong>
                                                                                                  \nIt returns the second of a minute from the date-time object.<\/span><\/p>\n

                                                                                                  ix. GetWeek(datetime)<\/strong>
                                                                                                  \nTo get the week of a year as a return from the date-time object, we use it.<\/span><\/p>\n

                                                                                                  x. GetWeekYear(datetime)<\/strong>
                                                                                                  \nGetWeekYear returns the week year from the date-time object.<\/span><\/p>\n

                                                                                                  xi. GetYear(datetime)<\/strong>
                                                                                                  \nIt returns the year from the date-time object.<\/span><\/p>\n

                                                                                                  xii. AddDuration(datetime, duration)<\/strong>
                                                                                                  \nTo get the result of a date-time object as a result along with the duration object, we use it.<\/span><\/p>\n

                                                                                                  xiii. SubtractDuration(datetime, duration)<\/strong>
                                                                                                  \nSubtractDuration<\/span>\u00a0subtracts the duration object from the Date-Time object and returns the result.<\/span><\/p>\n

                                                                                                  xiv. DaysBetween(datetime1, datetime2)<\/strong>
                                                                                                  \nDaysBetween r<\/span>eturns the number of days between the two date-time objects.<\/span><\/p>\n

                                                                                                  xv. HoursBetween(datetime1, datetime2)<\/strong>
                                                                                                  \nIt returns the number of hours between two date-time objects.<\/span><\/p>\n

                                                                                                  xvi. MilliSecondsBetween(datetime1, datetime2)<\/strong>
                                                                                                  \nTo get the number of milliseconds as result between two date-time objects, we use it.<\/span><\/p>\n

                                                                                                  xvii. MinutesBetween(datetime1, datetime2)<\/strong>
                                                                                                  \nMinutesBetween returns the number of minutes between two date-time objects.<\/span><\/p>\n

                                                                                                  xviii. MonthsBetween(datetime1, datetime2)<\/strong>
                                                                                                  \nTo get the number of months as a return between two date-time objects, we use it.<\/span><\/p>\n

                                                                                                  xix. SecondsBetween(datetime1, datetime2)<\/strong>
                                                                                                  \nIt returns the number of seconds between two date-time objects.<\/span><\/p>\n

                                                                                                  xx. WeeksBetween(datetime1, datetime2)<\/strong>
                                                                                                  \nWeeksBetween returns the number of weeks between two date-time objects.<\/span><\/p>\n

                                                                                                  xxi. YearsBetween(datetime1, datetime2)<\/strong>
                                                                                                  \nTo get the number of years as a return between two date-time objects, we use it.<\/span>
                                                                                                  \nAny doubt yet in Pig Built in functions? Please Comment.<\/p>\n

                                                                                                  f. Math Functions<\/span><\/h3>\n

                                                                                                  We have the following Math – Pig Built in functions\u2212<\/span><\/p>\n

                                                                                                  i. ABS(expression)<\/strong><\/p>\n

                                                                                                    \n
                                                                                                  • Syntax<\/span><\/li>\n<\/ul>\n

                                                                                                    ABS(expression)<\/span>
                                                                                                    \nIn order to get the absolute value of an expression.<\/span><\/p>\n

                                                                                                    ii. ACOS(expression)<\/strong><\/p>\n

                                                                                                      \n
                                                                                                    • Syntax<\/span><\/li>\n<\/ul>\n

                                                                                                      ACOS(expression)<\/span>
                                                                                                      \nIt gives the arc cosine of an expression.<\/span><\/p>\n

                                                                                                      iii. ASIN(expression)<\/strong><\/p>\n

                                                                                                        \n
                                                                                                      • Syntax<\/span><\/li>\n<\/ul>\n

                                                                                                        ASIN(expression)<\/span>
                                                                                                        \nASIN gives<\/span> the arc sine of an expression.<\/span><\/p>\n

                                                                                                        iv. ATAN(expression)<\/strong><\/p>\n

                                                                                                          \n
                                                                                                        • Syntax<\/span><\/li>\n<\/ul>\n

                                                                                                          ATAN(expression<\/span>
                                                                                                          \nTo get the arc tangent of an expression, we use it.<\/span><\/p>\n

                                                                                                          v. CBRT(expression)<\/strong><\/p>\n

                                                                                                            \n
                                                                                                          • Syntax<\/span><\/li>\n<\/ul>\n

                                                                                                            CBRT(expression)<\/span>
                                                                                                            \nIt gives the cube root of an expression.<\/span><\/p>\n

                                                                                                            vi. CEIL(expression)<\/strong><\/p>\n

                                                                                                              \n
                                                                                                            • Syntax<\/span><\/li>\n<\/ul>\n

                                                                                                              CEIL(expression)<\/span>
                                                                                                              \nCEIL<\/span> is used to get the value of an expression rounded up to the nearest integer.<\/span><\/p>\n

                                                                                                              vii. COS(expression)<\/strong><\/p>\n

                                                                                                                \n
                                                                                                              • Syntax<\/span><\/li>\n<\/ul>\n

                                                                                                                COS(expression)<\/span>
                                                                                                                \nIn order to get the trigonometric cosine of an expression.<\/span><\/p>\n

                                                                                                                viii. COSH(expression)<\/strong><\/p>\n

                                                                                                                  \n
                                                                                                                • Syntax<\/span><\/li>\n<\/ul>\n

                                                                                                                  COSH(expression)<\/span>
                                                                                                                  \nCOSH gives<\/span> the hyperbolic cosine of an expression.<\/span><\/p>\n

                                                                                                                  ix. EXP(expression)<\/strong><\/p>\n

                                                                                                                    \n
                                                                                                                  • Syntax<\/span><\/li>\n<\/ul>\n

                                                                                                                    EXP(expression)<\/span>
                                                                                                                    \nTo get the Euler\u2019s number e raised to the power of x.<\/span><\/p>\n

                                                                                                                    x. FLOOR(expression)<\/strong><\/p>\n

                                                                                                                      \n
                                                                                                                    • Syntax<\/span><\/li>\n<\/ul>\n

                                                                                                                      FLOOR(expression)<\/span>
                                                                                                                      \nIn order to get the value of an expression rounded down to the nearest integer.<\/span><\/p>\n

                                                                                                                      xi. LOG(expression)<\/strong><\/p>\n

                                                                                                                        \n
                                                                                                                      • Syntax<\/span><\/li>\n<\/ul>\n

                                                                                                                        LOG(expression)<\/span>
                                                                                                                        \nLOG gives the natural logarithm (base e) of an expression.<\/span><\/p>\n

                                                                                                                        xii. LOG10(expression)<\/strong><\/p>\n

                                                                                                                          \n
                                                                                                                        • Syntax<\/span><\/li>\n<\/ul>\n

                                                                                                                          LOG10(expression)<\/span>
                                                                                                                          \nIt gives the base 10 logarithms of an expression.<\/span><\/p>\n

                                                                                                                          xiii. RANDOM( )<\/strong><\/p>\n

                                                                                                                            \n
                                                                                                                          • Syntax<\/span><\/li>\n<\/ul>\n

                                                                                                                            RANDOM( )<\/span>
                                                                                                                            \nIn order to get a pseudo random number (type double) greater than or equal to 0.0 and less than 1.0.<\/span><\/p>\n

                                                                                                                            xiv. ROUND(expression)<\/strong><\/p>\n

                                                                                                                              \n
                                                                                                                            • Syntax<\/span><\/li>\n<\/ul>\n

                                                                                                                              ROUND(expression)<\/span>
                                                                                                                              \nROUND gives the value of an expression rounded to an integer (if the result type is float) or rounded to a long (if the result type is double).<\/span><\/p>\n

                                                                                                                              xv. SIN(expression)<\/strong><\/p>\n

                                                                                                                                \n
                                                                                                                              • Syntax<\/span><\/li>\n<\/ul>\n

                                                                                                                                SIN(expression)<\/span>
                                                                                                                                \nIn order to get the sine of an expression.<\/span><\/p>\n

                                                                                                                                xvi. SINH(expression)<\/strong><\/p>\n

                                                                                                                                  \n
                                                                                                                                • Syntax<\/span><\/li>\n<\/ul>\n

                                                                                                                                  SINH(expression)<\/span>
                                                                                                                                  \nIt gives the hyperbolic sine of an expression.<\/span><\/p>\n

                                                                                                                                  xvii. SQRT(expression)<\/strong><\/p>\n

                                                                                                                                    \n
                                                                                                                                  • Syntax<\/span><\/li>\n<\/ul>\n

                                                                                                                                    SQRT(expression)<\/span>
                                                                                                                                    \nSQRT<\/span> gives the positive square root of an expression.<\/span><\/p>\n

                                                                                                                                    xviii. TAN(expression)<\/strong><\/p>\n

                                                                                                                                      \n
                                                                                                                                    • Syntax<\/span><\/li>\n<\/ul>\n

                                                                                                                                      TAN(expression)<\/span>
                                                                                                                                      \nIn order to get the trigonometric tangent of an angle.<\/span><\/p>\n

                                                                                                                                      xix. TANH(expression)<\/strong><\/p>\n

                                                                                                                                        \n
                                                                                                                                      • Syntax<\/span><\/li>\n<\/ul>\n

                                                                                                                                        TANH(expression)<\/span>
                                                                                                                                        \nIt gives the hyperbolic tangent of an expression.<\/span>
                                                                                                                                        \nSo, this was all about Pig Built in Functions. Hope you like our explanation.<\/p>\n

                                                                                                                                        Conclusion: Apache Pig Built in Functions<\/span><\/h2>\n

                                                                                                                                        As a result, we have seen all the Apache Pig Built in Functions in detail. Moreover, we discussed string functions, math functions, load & store, bag & tuple, and eval functions. Still, if any doubt occurs, feel free to ask in the comments.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

                                                                                                                                        In this article “Apache Pig Built in Functions”, we will discuss all the Apache Pig Built-in Functions in detail. It includes eval, load\/store, math, bag and tuple functions and many more. Also, we will...<\/p>\n","protected":false},"author":7,"featured_media":25781,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[40],"tags":[4219,8348,8595,9503,13901],"class_list":["post-13958","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-pig","tag-eval-functions","tag-load-and-store-functions","tag-math-functions","tag-pig-functions","tag-string-functions"],"yoast_head":"\nApache Pig Built in Functions Cheat Sheet - DataFlair<\/title>\n<meta name=\"description\" content=\"Pig Built in Functions tutorial - what is Pig functions, Apache Pig tutorial, Eval Functions, Load & Store Functions,Bag & Tuple Functions, String Functions\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/data-flair.training\/blogs\/apache-pig-built-in-functions\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Apache Pig Built in Functions Cheat Sheet - DataFlair\" \/>\n<meta property=\"og:description\" content=\"Pig Built in Functions tutorial - what is Pig functions, Apache Pig tutorial, Eval Functions, Load & Store Functions,Bag & Tuple Functions, String Functions\" \/>\n<meta property=\"og:url\" content=\"https:\/\/data-flair.training\/blogs\/apache-pig-built-in-functions\/\" \/>\n<meta property=\"og:site_name\" content=\"DataFlair\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/DataFlairWS\/\" \/>\n<meta property=\"article:published_time\" content=\"2018-04-19T12:24:52+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/08\/Pig-Built-in-Functions-01.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"1200\" \/>\n\t<meta property=\"og:image:height\" content=\"628\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"DataFlair Team\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@DataFlairWS\" \/>\n<meta name=\"twitter:site\" content=\"@DataFlairWS\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"DataFlair Team\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"13 minutes\" \/>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Apache Pig Built in Functions Cheat Sheet - DataFlair","description":"Pig Built in Functions tutorial - what is Pig functions, Apache Pig tutorial, Eval Functions, Load & Store Functions,Bag & Tuple Functions, String Functions","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/data-flair.training\/blogs\/apache-pig-built-in-functions\/","og_locale":"en_US","og_type":"article","og_title":"Apache Pig Built in Functions Cheat Sheet - DataFlair","og_description":"Pig Built in Functions tutorial - what is Pig functions, Apache Pig tutorial, Eval Functions, Load & Store Functions,Bag & Tuple Functions, String Functions","og_url":"https:\/\/data-flair.training\/blogs\/apache-pig-built-in-functions\/","og_site_name":"DataFlair","article_publisher":"https:\/\/www.facebook.com\/DataFlairWS\/","article_published_time":"2018-04-19T12:24:52+00:00","og_image":[{"width":1200,"height":628,"url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/08\/Pig-Built-in-Functions-01.jpg","type":"image\/jpeg"}],"author":"DataFlair Team","twitter_card":"summary_large_image","twitter_creator":"@DataFlairWS","twitter_site":"@DataFlairWS","twitter_misc":{"Written by":"DataFlair Team","Est. reading time":"13 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/data-flair.training\/blogs\/apache-pig-built-in-functions\/#article","isPartOf":{"@id":"https:\/\/data-flair.training\/blogs\/apache-pig-built-in-functions\/"},"author":{"name":"DataFlair Team","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/person\/beb0cab24b7aa54423a3b50e669a9dcd"},"headline":"Apache Pig Built in Functions Cheat Sheet","datePublished":"2018-04-19T12:24:52+00:00","mainEntityOfPage":{"@id":"https:\/\/data-flair.training\/blogs\/apache-pig-built-in-functions\/"},"wordCount":3293,"commentCount":1,"publisher":{"@id":"https:\/\/data-flair.training\/blogs\/#organization"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/apache-pig-built-in-functions\/#primaryimage"},"thumbnailUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/08\/Pig-Built-in-Functions-01.jpg","keywords":["Eval Functions","Load and store Functions","Math functions","Pig Functions","String Functions"],"articleSection":["Pig Tutorials"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/data-flair.training\/blogs\/apache-pig-built-in-functions\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/data-flair.training\/blogs\/apache-pig-built-in-functions\/","url":"https:\/\/data-flair.training\/blogs\/apache-pig-built-in-functions\/","name":"Apache Pig Built in Functions Cheat Sheet - DataFlair","isPartOf":{"@id":"https:\/\/data-flair.training\/blogs\/#website"},"primaryImageOfPage":{"@id":"https:\/\/data-flair.training\/blogs\/apache-pig-built-in-functions\/#primaryimage"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/apache-pig-built-in-functions\/#primaryimage"},"thumbnailUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/08\/Pig-Built-in-Functions-01.jpg","datePublished":"2018-04-19T12:24:52+00:00","description":"Pig Built in Functions tutorial - what is Pig functions, Apache Pig tutorial, Eval Functions, Load & Store Functions,Bag & Tuple Functions, String Functions","breadcrumb":{"@id":"https:\/\/data-flair.training\/blogs\/apache-pig-built-in-functions\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/data-flair.training\/blogs\/apache-pig-built-in-functions\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/data-flair.training\/blogs\/apache-pig-built-in-functions\/#primaryimage","url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/08\/Pig-Built-in-Functions-01.jpg","contentUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/08\/Pig-Built-in-Functions-01.jpg","width":1200,"height":628,"caption":"Apache Pig Built in Functions Cheat Sheet"},{"@type":"BreadcrumbList","@id":"https:\/\/data-flair.training\/blogs\/apache-pig-built-in-functions\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Blog Home","item":"https:\/\/data-flair.training\/blogs\/"},{"@type":"ListItem","position":2,"name":"Pig Tutorials","item":"https:\/\/data-flair.training\/blogs\/category\/pig\/"},{"@type":"ListItem","position":3,"name":"Apache Pig Built in Functions Cheat Sheet"}]},{"@type":"WebSite","@id":"https:\/\/data-flair.training\/blogs\/#website","url":"https:\/\/data-flair.training\/blogs\/","name":"DataFlair","description":"Learn Today. Lead Tomorrow.","publisher":{"@id":"https:\/\/data-flair.training\/blogs\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/data-flair.training\/blogs\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/data-flair.training\/blogs\/#organization","name":"DataFlair","url":"https:\/\/data-flair.training\/blogs\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/logo\/image\/","url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2016\/07\/Data-Flair.png","contentUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2016\/07\/Data-Flair.png","width":106,"height":48,"caption":"DataFlair"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/DataFlairWS\/","https:\/\/x.com\/DataFlairWS","https:\/\/www.linkedin.com\/company\/dataflair-web-services-pvt-ltd\/","https:\/\/www.youtube.com\/user\/DataFlairWS"]},{"@type":"Person","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/person\/beb0cab24b7aa54423a3b50e669a9dcd","name":"DataFlair Team","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/secure.gravatar.com\/avatar\/c322416204232f4dd97ef3901b0a499a5d34d7ba7fe333f4bfe53a907873d293?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/c322416204232f4dd97ef3901b0a499a5d34d7ba7fe333f4bfe53a907873d293?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/c322416204232f4dd97ef3901b0a499a5d34d7ba7fe333f4bfe53a907873d293?s=96&d=mm&r=g","caption":"DataFlair Team"},"description":"DataFlair Team specializes in creating clear, actionable content on programming, Java, Python, C++, DSA, AI, ML, data Science, Android, Flutter, MERN, Web Development, and technology. Backed by industry expertise, we make learning easy and career-oriented for beginners and pros alike.","url":"https:\/\/data-flair.training\/blogs\/author\/dfteam3\/"}]}},"amp_enabled":true,"_links":{"self":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/13958","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/users\/7"}],"replies":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/comments?post=13958"}],"version-history":[{"count":0,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/13958\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/media\/25781"}],"wp:attachment":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/media?parent=13958"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/categories?post=13958"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/tags?post=13958"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}