{"id":22191,"date":"2018-08-08T07:00:35","date_gmt":"2018-08-08T07:00:35","guid":{"rendered":"https:\/\/data-flair.training\/blogs\/?p=22191"},"modified":"2018-08-08T07:00:35","modified_gmt":"2018-08-08T07:00:35","slug":"avro-schema","status":"publish","type":"post","link":"https:\/\/data-flair.training\/blogs\/avro-schema\/","title":{"rendered":"Avro Schema – Schema Declaration & Schema Resolution"},"content":{"rendered":"

Today, in this Apache Avro Tutorial<\/strong>, we will see Avro Schema. Moreover, in this Avro Schema, we will discuss the Schema declaration and Schema resolution. <\/span><\/p>\n

Also, we will learn how to create Avro Schema using JSON and data types in Schema i.e. primitive data types and complex data types in Apache Avro Schema. Along with this, we will understand Schemas in Apache Avro with Avro Schema Example.<\/span><\/p>\n

So, let’s start Apache Avro Schema.<\/p>\n

What is Avro Schema?<\/span><\/h2>\n

Basically, on schemas, only Avro relies on. The schema used, when Avro data is read, and when writing it is always present. By making serialization both fast and small, it allows each datum to be written with no-par-value overheads.<\/span><\/p>\n

Avro schema is stored with Avro data when it is stored in a file, hence that files may be later processed by any program. However, there could be an error occur, that the program reading the data expects a different schema. So, we can easily resolve because both schemas are present.<\/span><\/p>\n

The client and server in Avro exchange schemas in the connection handshake, while Avro is used in RPC. If somehow the client and the server both have the correspondence between same-named fields, other’s full schema, extra fields, missing fields, etc. we can easily resolve it.<\/span><\/p>\n

Since Avro schemas are defined with JSON<\/em>. Due to this reason, in all the languages that already have JSON libraries, it facilitates implementation.<\/span><\/p>\n

However, Avro accepts schemas as input. Avro follows its own standards of defining schemas, instead of variously available schemas. These schemas consist of various details \u2212<\/span><\/p>\n

    \n
  1. Type of file (record by default)<\/span><\/li>\n
  2. Location of record<\/span><\/li>\n
  3. Name of the record<\/span><\/li>\n
  4. Fields in the record with their corresponding data types<\/span><\/li>\n<\/ol>\n

    We can store serialized values in binary format using less space, with the help of these schemas. Also, note that even without any metadata, these values stores.<\/span><\/p>\n

    Schema Declaration\/Creating Avro Schemas Using JSON<\/span><\/h2>\n

    In a lightweight text-based data interchange format, JavaScript Object Notation (JSON), the Avro schema is created. It is possible to create Avro Schema using JSON in one of the several ways \u2212<\/span><\/p>\n

    \"Avro<\/a>

    Schema Declaration\/Creating Avro Schemas Using JSON<\/p><\/div>\n

      \n
    1. A JSON string<\/span><\/li>\n
    2. JSON object<\/span><\/li>\n
    3. A JSON array<\/span><\/li>\n<\/ol>\n

      a. Avro Schema Example<\/h3>\n

      Now, within “DataFlair”<\/em> namespace, the given schema defines a (record type) document. Here, Document\u2019s name is “Student” which consists of two “Fields” \u2192 Name and Age.<\/span><\/p>\n

      {\n  \"type\" : \"record\",\n  \"namespace\" : \"DataFlair\",\n  \"name\" : \"Student\",\n  \"fields\" : [\n     { \"name\" : \"Name\" , \"type\" : \"string\" },\n     { \"name\" : \"Age\" , \"type\" : \"int\" }\n  ]\n}<\/pre>\n
      As we can see there are four attributes in this schema, such as \u2212<\/span><\/p>\n
        \n
      • type <\/span><\/li>\n<\/ul>\n
        It describes document type, in this case, a “record”.<\/span><\/p>\n
          \n
        • namespace \u2212 <\/span><\/li>\n<\/ul>\n
          It illustrates the name of the namespace, where the object resides.<\/span><\/p>\n
            \n
          • name<\/span><\/li>\n<\/ul>\n
            It explains the schema name.<\/span><\/p>\n
              \n
            • fields <\/span><\/li>\n<\/ul>\n
              It is an attribute array which consists of:<\/span><\/p>\n
                \n
              • name <\/span><\/li>\n<\/ul>\n
                It describes the name of the field<\/span><\/p>\n
                  \n
                • Type<\/span><\/li>\n<\/ul>\n
                  It describes data type of field<\/span><\/p>\n
                  b. Primitive Types<\/span><\/h3>\n
                  Here is the list of primitive type names in Apache Avro Schema:<\/span><\/p>\n
                    \n
                  1.  null:<\/strong> no value.<\/span><\/li>\n
                  2.  boolean:<\/strong> a binary value.<\/span><\/li>\n
                  3.  int:<\/strong> 32-bit signed integer.<\/span><\/li>\n
                  4.  long:<\/strong> 64-bit signed integer.<\/span><\/li>\n
                  5.  float:<\/strong> single precision (32-bit) IEEE 754 floating-point number.<\/span><\/li>\n
                  6.  double:<\/strong> double precision (64-bit) IEEE 754 floating-point number.<\/span><\/li>\n
                  7.  bytes:<\/strong> the sequence of 8-bit unsigned bytes.<\/span><\/li>\n
                  8.  string:<\/strong> Unicode character sequence.<\/span><\/li>\n
                  9.  Primitive types have no specified attributes.<\/span><\/li>\n<\/ol>\n
                    c. Complex Types<\/span><\/h3>\n
                    There are six kinds of complex types in Apache Avro Schema, such as:<\/span><\/p>\n
                    i. Avro Schema Records<\/h4>\n
                    Basically, it uses the type name “record” and does support various attributes, such as:<\/span><\/p>\n
                      \n
                    • name<\/span><\/li>\n<\/ul>\n
                      It is a JSON string<\/em> which describes the name of the record (required).<\/span><\/p>\n
                        \n
                      • namespace<\/span><\/li>\n<\/ul>\n
                        This is a JSON string which qualifies the name;<\/span><\/p>\n
                          \n
                        • Doc<\/span><\/li>\n<\/ul>\n
                          It is a JSON string which provides documentation to the user of this schema (optional).<\/span><\/p>\n
                            \n
                          • aliases<\/span><\/li>\n<\/ul>\n
                            This is a JSON array of strings, which describes the alternate names for this record (optional).<\/span><\/p>\n
                              \n
                            • fields<\/span><\/li>\n<\/ul>\n
                              It is a JSON array, listing fields (required).<\/span>\u00a0<\/span><\/p>\n
                              ii. Avro Schema Enums<\/h4>\n
                              It uses \u00a0the type name “enum” \u00a0also do supports various attributes:<\/span><\/p>\n
                                \n
                              • name<\/span><\/li>\n<\/ul>\n
                                It is a JSON string which provides the name of the enum (required).<\/span><\/p>\n
                                  \n
                                • namespace, <\/span><\/li>\n<\/ul>\n
                                  This is a JSON string which qualifies the name;<\/span><\/p>\n
                                    \n
                                  • aliases<\/span><\/li>\n<\/ul>\n
                                    It is a JSON array of strings, which provides the alternate names for this enum (optional).<\/span><\/p>\n
                                      \n
                                    • doc<\/span><\/li>\n<\/ul>\n
                                      This is a JSON string which provides documentation to the user of this schema (optional).<\/span><\/p>\n
                                        \n
                                      • symbols<\/span><\/li>\n<\/ul>\n
                                        It is a JSON array, listing symbols, as JSON strings (required). Make sure, all the symbols in an enum must be Arrays.<\/span><\/p>\n
                                        iii. Arrays in Avro Schema<\/strong><\/h4>\n
                                        It uses the type name “array” and supports only one attribute:<\/span><\/p>\n
                                          \n
                                        • items<\/span><\/li>\n<\/ul>\n
                                          It is simply the schema of the array’s items.<\/span><\/p>\n
                                          iv. Avro Schema Maps<\/strong><\/h4>\n
                                          It uses the type name “map” and does support only one attribute:<\/span><\/p>\n
                                            \n
                                          • values<\/span><\/li>\n<\/ul>\n
                                            It is the schema of the map’s values. Make sure, Map keys are assumed to be strings.<\/span><\/p>\n
                                            v. Unions in Avro Schema<\/strong><\/h4>\n
                                            By using JSON arrays, Unions are represented. Make sure, Unions may not contain other unions, immediately.<\/span><\/p>\n
                                            vi. Fixed Avro Schema<\/strong><\/h4>\n
                                            It uses the type name “fixed” and does support the following attributes:<\/span><\/p>\n
                                              \n
                                            • name<\/span><\/li>\n<\/ul>\n
                                              It is a string naming this fixed (required).<\/span><\/p>\n
                                                \n
                                              • namespace<\/span><\/li>\n<\/ul>\n
                                                This is a string that qualifies the name.<\/span><\/p>\n
                                                Schema Resolution<\/span><\/h2>\n
                                                At times, this is possible that the schema which is present may not be exactly the schema that was expected. Let\u2019s understand Avro Schema Resolution in this way, the versions of both read and write of data are different, then records may have had fields added or removed.<\/span><\/p>\n
                                                Basically, the schema which we use to write the data is what we call the writer’s schema, or the schema what the application expects is the reader’s schema. So, the differences between both must be resolved as follows: <\/span><\/p>\n
                                                A. If the two schemas do not match, this is an error.<\/strong>
                                                \nSo, in order to match, one of the following statement must hold:<\/span><\/p>\n
                                                  \n
                                                1. It is must that both schemas are arrays, whose item types match.<\/span><\/li>\n
                                                2. When both schemas are maps their value types must match.<\/span><\/li>\n
                                                3. It is must that both the schemas are enums and their names match.<\/span><\/li>\n
                                                4. Moreover, both schemas\u00a0which are present their sizes and names must match.<\/span><\/li>\n
                                                5. Both the schemas are records but with the same name<\/span><\/li>\n
                                                6. It is possible either schema is a union.<\/span><\/li>\n
                                                7. It is the must that both schemas have the same primitive type.<\/span><\/li>\n
                                                8. Now, make sure that the writer’s schema may promote to the reader’s as follows:<\/span><\/li>\n<\/ol>\n
                                                    \n
                                                  • Int is promotable to long, float, or double.<\/span><\/li>\n
                                                  • Long is promotable to float or double.<\/span><\/li>\n
                                                  • The float is promotable to double.<\/span><\/li>\n<\/ul>\n
                                                    B. If both are records<\/strong><\/p>\n
                                                      \n
                                                    1. It is possible that the that the fields are matched by name and order of fields may be different.<\/span><\/li>\n
                                                    2. Make sure the schemas for fields with the same name in both records\u00a0resolve\u00a0recursively.<\/span><\/li>\n
                                                    3. The writer’s value for that field is ignored if the writer’s record contains a field with a name not present in the reader’s record.<\/span><\/li>\n
                                                    4. The reader should use the default value from its field, if the reader’s record schema has a field that contains a default value, and writer’s schema does not have a field with the same name.<\/span><\/li>\n
                                                    5. An error occurs, if somehow the reader’s record schema has a field with no default value, and the writer’s schema does not have a field with the same name.<\/span><\/li>\n<\/ol>\n
                                                      C. If both are enums<\/strong><\/p>\n
                                                      An error occurs if the writer’s symbol is not present in the reader’s enum.<\/span><\/p>\n
                                                      D. If both are arrays<\/strong><\/p>\n
                                                      Moreover, there is a case when both are arrays, then this resolution algorithm must apply recursively to the reader’s and writer’s array item schemas.<\/span><\/p>\n
                                                      E. If both are maps<\/strong><\/p>\n
                                                      Further, if both are maps, then this resolution algorithm is applied recursively to the reader’s and writer’s value schemas.<\/span><\/p>\n
                                                      F.<\/strong> If in any case the reader’s is a union, but the writer’s one is not,<\/strong> then the in the reader’s union, the first schema, that matches the <\/span><\/p>\n
                                                      writer’s schema is recursively resolved against it. Here also, an error occurs, if none match.<\/span><\/p>\n
                                                      G. When a case occurs when a writer is a union, but the reader’s\u00a0one is not,<\/strong>\u00a0and if the reader’s schema matches the selected <\/span>writer’s schema, it is recursively resolved against it. An error\u00a0occurs if they do not match.<\/span><\/p>\n
                                                      So, this was all in Apache Avro Schema. Hope you like our explanation.<\/p>\n
                                                      Conclusion: Avro Schema<\/span><\/h2>\n
                                                      Hence, in this Avro Schema tutorial, we have learned the whole about Apache Avro Schemas in detail which also includes Schema Declaration & Avro Schema Resolution to understand well.<\/span><\/p>\n
                                                       Also, we saw Avro Schema example and creating Avro Schema from JSON. Still, if any doubt, ask in the comment tab.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"
                                                      Today, in this Apache Avro Tutorial, we will see Avro Schema. Moreover, in this Avro Schema, we will discuss the Schema declaration and Schema resolution. Also, we will learn how to create Avro Schema...<\/p>\n","protected":false},"author":7,"featured_media":22261,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[12],"tags":[737,1303,1304,1305,1306,1307,1308,1309,1310,1312,2796,3050,3051,9966,15034],"class_list":["post-22191","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-avro","tag-apache-avro","tag-avro-schem-registry","tag-avro-schema","tag-avro-schema-evolution","tag-avro-schema-example","tag-avro-schema-generator","tag-avro-schema-map-example","tag-avro-schema-multiple-records","tag-avro-schema-optional-field","tag-avro-schema-validator","tag-complex-data-types","tag-create-avro-schema","tag-create-avro-schema-using-json","tag-primitive-data-types","tag-types-of-complex-data-types"],"yoast_head":"\nAvro Schema - Schema Declaration & Schema Resolution - DataFlair<\/title>\n<meta name=\"description\" content=\"Apache Avro Schema,Avro schema resolution,avro schema declaration,avro schema example,generate avro schema from JSON,avro data types- primitive,complex\" \/>\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\/avro-schema\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Avro Schema - Schema Declaration & Schema Resolution - DataFlair\" \/>\n<meta property=\"og:description\" content=\"Apache Avro Schema,Avro schema resolution,avro schema declaration,avro schema example,generate avro schema from JSON,avro data types- primitive,complex\" \/>\n<meta property=\"og:url\" content=\"https:\/\/data-flair.training\/blogs\/avro-schema\/\" \/>\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-08-08T07:00:35+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/07\/Apache-Avro-Schema-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=\"7 minutes\" \/>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Avro Schema - Schema Declaration & Schema Resolution - DataFlair","description":"Apache Avro Schema,Avro schema resolution,avro schema declaration,avro schema example,generate avro schema from JSON,avro data types- primitive,complex","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\/avro-schema\/","og_locale":"en_US","og_type":"article","og_title":"Avro Schema - Schema Declaration & Schema Resolution - DataFlair","og_description":"Apache Avro Schema,Avro schema resolution,avro schema declaration,avro schema example,generate avro schema from JSON,avro data types- primitive,complex","og_url":"https:\/\/data-flair.training\/blogs\/avro-schema\/","og_site_name":"DataFlair","article_publisher":"https:\/\/www.facebook.com\/DataFlairWS\/","article_published_time":"2018-08-08T07:00:35+00:00","og_image":[{"width":1200,"height":628,"url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/07\/Apache-Avro-Schema-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":"7 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/data-flair.training\/blogs\/avro-schema\/#article","isPartOf":{"@id":"https:\/\/data-flair.training\/blogs\/avro-schema\/"},"author":{"name":"DataFlair Team","@id":"https:\/\/data-flair.training\/blogs\/#\/schema\/person\/beb0cab24b7aa54423a3b50e669a9dcd"},"headline":"Avro Schema – Schema Declaration & Schema Resolution","datePublished":"2018-08-08T07:00:35+00:00","mainEntityOfPage":{"@id":"https:\/\/data-flair.training\/blogs\/avro-schema\/"},"wordCount":1446,"commentCount":2,"publisher":{"@id":"https:\/\/data-flair.training\/blogs\/#organization"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/avro-schema\/#primaryimage"},"thumbnailUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/07\/Apache-Avro-Schema-01.jpg","keywords":["Apache Avro","Avro Schem registry","Avro Schema","Avro Schema evolution","Avro Schema example","Avro Schema generator","Avro Schema Map example","Avro Schema Multiple Records","Avro Schema Optional Field","Avro Schema Validator","Complex data Types","Create avro Schema","create Avro Schema using JSON","Primitive data Types","types of Complex data types"],"articleSection":["AVRO Tutorials"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/data-flair.training\/blogs\/avro-schema\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/data-flair.training\/blogs\/avro-schema\/","url":"https:\/\/data-flair.training\/blogs\/avro-schema\/","name":"Avro Schema - Schema Declaration & Schema Resolution - DataFlair","isPartOf":{"@id":"https:\/\/data-flair.training\/blogs\/#website"},"primaryImageOfPage":{"@id":"https:\/\/data-flair.training\/blogs\/avro-schema\/#primaryimage"},"image":{"@id":"https:\/\/data-flair.training\/blogs\/avro-schema\/#primaryimage"},"thumbnailUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/07\/Apache-Avro-Schema-01.jpg","datePublished":"2018-08-08T07:00:35+00:00","description":"Apache Avro Schema,Avro schema resolution,avro schema declaration,avro schema example,generate avro schema from JSON,avro data types- primitive,complex","breadcrumb":{"@id":"https:\/\/data-flair.training\/blogs\/avro-schema\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/data-flair.training\/blogs\/avro-schema\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/data-flair.training\/blogs\/avro-schema\/#primaryimage","url":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/07\/Apache-Avro-Schema-01.jpg","contentUrl":"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/07\/Apache-Avro-Schema-01.jpg","width":1200,"height":628,"caption":"Avro Schema - Schema Declaration & Schema Resolution"},{"@type":"BreadcrumbList","@id":"https:\/\/data-flair.training\/blogs\/avro-schema\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Blog Home","item":"https:\/\/data-flair.training\/blogs\/"},{"@type":"ListItem","position":2,"name":"AVRO Tutorials","item":"https:\/\/data-flair.training\/blogs\/category\/avro\/"},{"@type":"ListItem","position":3,"name":"Avro Schema – Schema Declaration & Schema Resolution"}]},{"@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\/22191","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=22191"}],"version-history":[{"count":0,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/posts\/22191\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/media\/22261"}],"wp:attachment":[{"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/media?parent=22191"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/categories?post=22191"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/data-flair.training\/blogs\/wp-json\/wp\/v2\/tags?post=22191"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}