{"id":14196,"date":"2018-04-21T09:09:41","date_gmt":"2018-04-21T09:09:41","guid":{"rendered":"https:\/\/data-flair.training\/blogs\/?p=14196"},"modified":"2018-04-21T09:09:41","modified_gmt":"2018-04-21T09:09:41","slug":"pig-latin","status":"publish","type":"post","link":"https:\/\/data-flair.training\/blogs\/pig-latin\/","title":{"rendered":"What is Pig Latin and its Operators"},"content":{"rendered":"

Apache Pig<\/strong> offers High-level language like Pig Latin to perform data analysis programs. So, in this Pig Latin tutorial, we will discuss the basics of Pig Latin. Such as Pig Latin statements, data types, general operators, and Pig Latin UDF in detail. Also, we will see its examples to understand it well.<\/span><\/p>\n

So, let’s start the Pig Latin Tutorial.<\/p>\n

What is Pig Latin? <\/span><\/h2>\n

While we need to analyze data in Hadoop<\/strong> using Apache Pig, we use Pig Latin language. Basically, first, we need to transform Pig Latin statements into MapReduce<\/strong> jobs using an interpreter layer. In this way, the Hadoop process these jobs. <\/span><\/p>\n

However, we can say, Pig Latin is a very simple language with SQL like semantics. It is possible to use it in a productive manner. It also contains a rich set of functions. Those exhibits data manipulation. <\/span><\/p>\n

Moreover, \u00a0by writing user-defined functions (UDF) using \u00a0Java<\/strong>, we can extend them easily. That implies they are extensible in nature.<\/span><\/p>\n

Data Model in Pig Latin<\/span><\/h2>\n

The data model of Pig is fully nested. In addition, the outermost structure of the Pig Latin data model is a Relation. Also, it is a bag. While\u2212<\/span><\/p>\n

    \n
  • A bag, what we call a collection of tuples.<\/span><\/li>\n
  • A tuple, what we call an ordered set of fields.<\/span><\/li>\n
  • A field, what we call a piece of data.<\/span><\/li>\n<\/ul>\n

    Statements in Pig Latin<\/span><\/h2>\n

    Also, make sure, statements are the basic constructs while processing data using Pig Latin.<\/span><\/p>\n

      \n
    • Basically, \u00a0statements work with relations. Also, \u00a0includes expressions and schemas.<\/span><\/li>\n
    • Here, every statement ends with a semicolon (;).<\/span><\/li>\n
    • Moreover, through statements, we will perform several operations using operators, those are offered by Pig Latin.<\/span><\/li>\n
    • However, Pig Latin statements take a relation as input and produce another relation as output, while performing all other operations Except LOAD and STORE.<\/span><\/li>\n
    • Its semantic checking will be carried out, once we enter a Load statement in the Grunt shell. Although, we need to use the Dump operator, in order to see the contents of the schema. Because, the MapReduce job for loading the data into the file system will be carried out, only after performing the dump operation.<\/span><\/li>\n<\/ul>\n

      Pig Latin Example –<\/span>
      \nHere, is a Pig Latin statement. Basically, that loads data to Apache Pig.<\/span><\/p>\n

      grunt> Employee_data = LOAD 'Employee_data.txt' USING PigStorage(',')as\n  ( id:int, firstname:chararray, lastname:chararray, phone:chararray, city:chararray );<\/pre>\n
      Pig Latin Datatypes
      \n<\/span><\/h2>\n
      Further, is the list of Pig Latin data types. Such as:<\/span><\/p>\n
        \n
      •  int<\/span><\/li>\n<\/ul>\n
        \u201cInt\u201d represents a signed 32-bit integer.<\/span>
        \nFor Example: 10<\/span><\/p>\n
          \n
        •  long<\/span><\/li>\n<\/ul>\n
          It represents a signed 64-bit integer.<\/span>
          \nFor Example: 10L<\/span><\/p>\n
            \n
          •  float<\/span><\/li>\n<\/ul>\n
            This data type represents a signed 32-bit floating point.<\/span>
            \nFor Example: 10.5F<\/span><\/p>\n
              \n
            •  double<\/span><\/li>\n<\/ul>\n
              \u201cdouble\u201d represents a 64-bit floating point.<\/span>
              \nFor Example: 10.5<\/span><\/p>\n
                \n
              •  chararray<\/span><\/li>\n<\/ul>\n
                It represents a character array (string) in Unicode UTF-8 format.<\/span>
                \nFor Example: \u2018Data Flair\u2019<\/span><\/p>\n
                  \n
                •  Bytearray<\/span><\/li>\n<\/ul>\n
                  This data type represents a Byte array (blob).<\/span><\/p>\n
                    \n
                  •  Boolean<\/span><\/li>\n<\/ul>\n
                    \u201cBoolean\u201d represents a Boolean value.<\/span>
                    \nFor Example : true\/ false. <\/span>
                    \nNote: It is case insensitive.<\/span><\/p>\n
                      \n
                    •  Datetime<\/span><\/li>\n<\/ul>\n
                      It represents a date-time.<\/span>
                      \nFor Example : 1970-01-01T00:00:00.000+00:00<\/span><\/p>\n
                        \n
                      •  Biginteger<\/span><\/li>\n<\/ul>\n
                        This data type represents a Java BigInteger.<\/span>
                        \nFor Example: 60708090709<\/span><\/p>\n
                          \n
                        •  Bigdecimal<\/span><\/li>\n<\/ul>\n
                          \u201cBigdecimal\u201d represents a Java BigDecimal<\/span>
                          \nFor Example: 185.98376256272893883<\/span><\/p>\n
                          i.Complex Types<\/h3>\n
                            \n
                          •  Tuple<\/span><\/li>\n<\/ul>\n
                            An ordered set of fields is what we call a tuple.<\/span>
                            \nFor Example : (Ankit, 32)<\/span><\/p>\n
                              \n
                            •  Bag<\/span><\/li>\n<\/ul>\n
                              A collection of tuples is what we call a bag.<\/span>
                              \nFor Example : {(Ankit,32),(Neha,30)}<\/span><\/p>\n
                                \n
                              •  Map<\/span><\/li>\n<\/ul>\n
                                A set of key-value pairs is what we call a Map.<\/span>
                                \nExample : [ \u2018name\u2019#\u2019Ankit\u2019, \u2018age\u2019#32]<\/span><\/p>\n
                                ii. Null Values<\/h3>\n
                                It is possible that values for all the above data types can be NULL. However, SQL and Pig treat null values in the same way.<\/span><\/p>\n
                                On defining a null Value, It can be an unknown value or a non-existent value. Moreover, we use it as a placeholder for optional values. Either, These nulls can be the result of an operation or it can occur naturally.<\/span><\/p>\n
                                Pig Latin Arithmetic Operators
                                \n<\/span><\/h2>\n
                                Here, is the list of arithmetic operators of Pig Latin. Let\u2019s assume,value of A = 20 and B = 40.<\/span><\/p>\n
                                  \n
                                •  +<\/span><\/li>\n<\/ul>\n
                                  Addition \u2212 It simply adds values on either side of the operator.<\/span>
                                  \nFor Example: 60, it comes to adding A+B.<\/span><\/p>\n
                                    \n
                                  •  \u2212<\/span><\/li>\n<\/ul>\n
                                    Subtraction – This operator subtracts right-hand operand from left-hand operand.<\/span>
                                    \nFor Example: \u221220, it comes on subtracting A-B<\/span><\/p>\n
                                      \n
                                    •  *<\/span><\/li>\n<\/ul>\n
                                      Multiplication \u2212 It simply Multiplies values on either side of the operators.<\/span>
                                      \nFor Example: 800, it comes to multiplying A*B.<\/span><\/p>\n
                                        \n
                                      •  \/<\/span><\/li>\n<\/ul>\n
                                        Division \u2212 This operator divides left-hand operand by right-hand operand<\/span>
                                        \nFor Example: 2, \u00a0it comes to dividing, b\/a<\/span><\/p>\n
                                          \n
                                        •  %<\/span><\/li>\n<\/ul>\n
                                          Modulus \u2212 It Divides left-hand operand by right-hand operand and returns the remainder<\/span>
                                          \nFor Example: 0, it comes to dividing, b % a.<\/span><\/p>\n
                                            \n
                                          •  ? :<\/span><\/li>\n<\/ul>\n
                                            Bincond \u2212 This operator evaluates the Boolean operators. Generally, \u00a0it has three operands. Such as:<\/span>
                                            \nvariable x = (expression) ?, value1 if true or value2 if false.<\/span>
                                            \nFor Example:<\/span><\/p>\n
                                            b = (a == 1)? 20: 40;\nif a = 1 the value of b is 20.\nif a!=1 the value of b is 40.<\/pre>\n
                                              \n
                                            •  CASE<\/span><\/li>\n<\/ul>\n
                                              WHEN<\/span>
                                              \nTHEN<\/span>
                                              \nELSE END<\/span>
                                              \nCase \u2212 It is equivalent to the nested bincond operator.<\/span>
                                              \nFor Example- CASE f2 % 2<\/span>
                                              \nWHEN 0 THEN ‘even’<\/span>
                                              \nWHEN 1 THEN ‘odd’<\/span>
                                              \nEND<\/span><\/p>\n
                                              Comparison Operators in Pig Latin
                                              \n<\/span><\/h2>\n
                                              Here, is the list of the comparison operators of Pig Latin. Let\u2019s assume,value of A = 20 and B = 40.<\/span><\/p>\n
                                                \n
                                              •  ==<\/span><\/li>\n<\/ul>\n
                                                Equal \u2212 This operator checks if the values of two operands are equal or not. So, if yes, then the condition becomes true.<\/span>
                                                \nFor Example- (a = b) is not true<\/span><\/p>\n
                                                  \n
                                                •  !=<\/span><\/li>\n<\/ul>\n
                                                  Not Equal \u2212 It will check if the values of two operands are equal or not. So, if the values are not equal, then condition becomes true.<\/span>
                                                  \nFor Example- (a != b) is true.<\/span><\/p>\n
                                                    \n
                                                  •  ><\/span><\/li>\n<\/ul>\n
                                                    Greater than \u2212 This operator checks if the value of the left operand is greater than the value of the right operand. Hence, \u00a0if yes, then the condition becomes true.<\/span>
                                                    \nFor Example- (a > b) is not true.<\/span><\/p>\n
                                                      \n
                                                    •  <<\/span><\/li>\n<\/ul>\n
                                                      Less than \u2212 It simply checks if the value of the left operand is less than the value of the right operand. So, if yes, then the condition becomes true.<\/span>
                                                      \nFor Example- (a < b) is true.<\/span><\/p>\n
                                                        \n
                                                      •  >=<\/span><\/li>\n<\/ul>\n
                                                        Greater than or equal to \u2212 It will check if the value of the left operand is greater than or equal to the value of the right operand. Hence, if yes, then the condition becomes true.<\/span>
                                                        \nFor Example- (a >= b) is not true.<\/span><\/p>\n
                                                          \n
                                                        •  <=<\/span><\/li>\n<\/ul>\n
                                                          Less than or equal to \u2212 This operator checks if the value of the left operand is less than or equal to the value of the right operand. So, if yes, then the condition becomes true.<\/span>
                                                          \nFor Example- (a <= b) is true.<\/span><\/p>\n
                                                            \n
                                                          •  matches<\/span><\/li>\n<\/ul>\n
                                                            Pattern matching \u2212 It simply checks whether the string in the left-hand side matches with the constant in the right-hand side.<\/span>
                                                            \nFor Example- f1 matches ‘.*dataflair.*’<\/span><\/p>\n
                                                            Type Construction Operators
                                                            \n<\/span><\/h2>\n
                                                            Here, is the list of the Type construction operators of Pig Latin.<\/span><\/p>\n
                                                              \n
                                                            •  ()<\/span><\/li>\n<\/ul>\n
                                                              Tuple constructor operator \u2212 To construct a tuple, we use this operator.<\/span>
                                                              \nFor Example- (Ankit, 32)<\/span><\/p>\n
                                                                \n
                                                              •  {}<\/span><\/li>\n<\/ul>\n
                                                                Bag constructor operator \u2212 Moreover, to construct a bag, we use this operator.<\/span>
                                                                \nFor Example- {(Ankit, 32), (Neha, 30)}<\/span><\/p>\n
                                                                  \n
                                                                • []<\/span><\/li>\n<\/ul>\n
                                                                  Map constructor operator \u2212 In order to construct a tuple, we use this operator.<\/span>
                                                                  \nFor Example- [name#Ankit, age#32]<\/span><\/p>\n
                                                                  So, this was all in Pig Latin Tutorial. Hope you like our explanation.<\/p>\n
                                                                  Conclusion
                                                                  \n<\/span><\/h2>\n
                                                                  As a result, we have seen what is Apache Pig Latin. Also, we discussed the basic Pig Latin statements, data types, general operators with examples. Hence, we hope this article will help you a lot. Still, if any doubt occurs, feel free to ask in the comment section.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"
                                                                  Apache Pig offers High-level language like Pig Latin to perform data analysis programs. So, in this Pig Latin tutorial, we will discuss the basics of Pig Latin. Such as Pig Latin statements, data types,...<\/p>\n","protected":false},"author":7,"featured_media":35466,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[40],"tags":[1110,3384,9510,9512,13770,15845],"class_list":["post-14196","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-pig","tag-arithmetic-operators-pig-latin","tag-data-model-in-pig-latin","tag-pig-latin","tag-pig-latin-data-types","tag-statements-in-pig-latin","tag-what-is-pig-latin"],"yoast_head":"\nWhat is Pig Latin and its Operators - DataFlair<\/title>\n<meta name=\"description\" content=\"Pig latin tutorial, what is Pig Latin, Pig latin operators, Pig Latin Statements, Pig latin Arithmetic Operators, Pig Latin Data Model\" \/>\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\/pig-latin\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"What is Pig Latin and its Operators - DataFlair\" \/>\n<meta property=\"og:description\" content=\"Pig latin tutorial, what is Pig Latin, Pig latin operators, Pig Latin Statements, Pig latin Arithmetic Operators, Pig Latin Data Model\" \/>\n<meta property=\"og:url\" content=\"https:\/\/data-flair.training\/blogs\/pig-latin\/\" \/>\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-21T09:09:41+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/04\/Apache-Pig-Latin-01-1-1.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=\"6 minutes\" \/>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"What is Pig Latin and its Operators - DataFlair","description":"Pig latin tutorial, what is Pig Latin, Pig latin operators, Pig Latin Statements, Pig latin Arithmetic Operators, Pig Latin Data Model","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\/pig-latin\/","og_locale":"en_US","og_type":"article","og_title":"What is Pig Latin and its Operators - DataFlair","og_description":"Pig latin tutorial, what is Pig Latin, Pig latin operators, Pig Latin Statements, Pig latin Arithmetic Operators, Pig Latin Data Model","og_url":"https:\/\/data-flair.training\/blogs\/pig-latin\/","og_site_name":"DataFlair","article_publisher":"https:\/\/www.facebook.com\/DataFlairWS\/","article_published_time":"2018-04-21T09:09:41+00:00","og_image":[{"width":1200,"height":628,"url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/04\/Apache-Pig-Latin-01-1-1.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":"6 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/data-flair.training\/blogs\/pig-latin\/#article","isPartOf":{"@id":"https:\/\/data-flair.training\/blogs\/pig-latin\/"},"author":{"name":"DataFlair Team","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/person\/beb0cab24b7aa54423a3b50e669a9dcd"},"headline":"What is Pig Latin and its Operators","datePublished":"2018-04-21T09:09:41+00:00","mainEntityOfPage":{"@id":"https:\/\/data-flair.training\/blogs\/pig-latin\/"},"wordCount":1179,"commentCount":0,"publisher":{"@id":"https:\/\/data-flair.training\/blogs\/#organization"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/pig-latin\/#primaryimage"},"thumbnailUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/04\/Apache-Pig-Latin-01-1-1.jpg","keywords":["Arithmetic Operators: Pig Latin","Data Model in Pig Latin","Pig Latin","Pig Latin Data types","Statements in Pig Latin","What is Pig Latin"],"articleSection":["Pig Tutorials"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/data-flair.training\/blogs\/pig-latin\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/data-flair.training\/blogs\/pig-latin\/","url":"https:\/\/data-flair.training\/blogs\/pig-latin\/","name":"What is Pig Latin and its Operators - DataFlair","isPartOf":{"@id":"https:\/\/data-flair.training\/blogs\/#website"},"primaryImageOfPage":{"@id":"https:\/\/data-flair.training\/blogs\/pig-latin\/#primaryimage"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/pig-latin\/#primaryimage"},"thumbnailUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/04\/Apache-Pig-Latin-01-1-1.jpg","datePublished":"2018-04-21T09:09:41+00:00","description":"Pig latin tutorial, what is Pig Latin, Pig latin operators, Pig Latin Statements, Pig latin Arithmetic Operators, Pig Latin Data Model","breadcrumb":{"@id":"https:\/\/data-flair.training\/blogs\/pig-latin\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/data-flair.training\/blogs\/pig-latin\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/data-flair.training\/blogs\/pig-latin\/#primaryimage","url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/04\/Apache-Pig-Latin-01-1-1.jpg","contentUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/04\/Apache-Pig-Latin-01-1-1.jpg","width":1200,"height":628,"caption":"What is Pig Latin and its Operators"},{"@type":"BreadcrumbList","@id":"https:\/\/data-flair.training\/blogs\/pig-latin\/#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":"What is Pig Latin and its Operators"}]},{"@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\/14196","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=14196"}],"version-history":[{"count":0,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/14196\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/media\/35466"}],"wp:attachment":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/media?parent=14196"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/categories?post=14196"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/tags?post=14196"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}