{"id":1109,"date":"2016-02-22T09:55:49","date_gmt":"2016-02-22T09:55:49","guid":{"rendered":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/?p=1109"},"modified":"2020-09-25T11:45:28","modified_gmt":"2020-09-25T11:45:28","slug":"the-dark-side-of-parsing","status":"publish","type":"post","link":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/the-dark-side-of-parsing\/","title":{"rendered":"The Dark Side of Parsing"},"content":{"rendered":"\n

Differences in performance with Oracle when using native queries vs. prepared statements<\/strong><\/strong><\/p>\n\n\n\n

Generally speaking, native database queries in an application complicate its maintainability and the possibility to develop independently of a specific database. Within the framework of a performance analysis of an old Java application with an Oracle database, we discovered another aspect that constitutes an argument against using this kind of query: the performance compared to prepared statements in the context of an Oracle database.<\/p>\n\n\n\n

The starting point was an analysis carried out by Oracle\u2019s Automatic Database Diagnostic Monitor (ADDM)[1]<\/a>. This feature analyzes SQL queries, among other things, and makes recommendations. In this case, it produced the following message for a number of queries:<\/p>\n\n\n\n

Hard parse due to literal usage: SQL statements were not shared due to the usage of literals. This resulted in additional hard parses which were consuming significant database time<\/em>.<\/em><\/p>\n\n\n\n

Investigate application logic for possible use of bind variables instead of literals<\/em>.<\/em><\/p>\n\n\n\n

Usage of literals in this context means the insertion of the actual values into the conditions, e.g.:<\/p>\n\n\n\n

<\/div>\n\n\n\n
    SELECT * FROM my_table WHERE my_field = 123<\/code><\/pre>\n\n\n\n
<\/div>\n\n\n\n
By contrast, when you use bind variables, the specific value is replaced by a placeholder, and it is inserted only in the subsequent step.<\/p>\n\n\n\n
<\/div>\n\n\n\n
Performance analysis: Literal vs. bind variables<\/strong><\/h2>\n\n\n\n
Now, how do these two options affect the performance of the database queries, and what causes these effects? To answer that, we need to look at the way Oracle processes queries. Before actually executing it, the query needs to be parsed in order to identify possible execution plans. For example, the system checks whether and in what way an index can be used. This \u201chard parse\u201d is necessary to determine the optimal access plan, and it can take longer than the execution itself. However, Oracle saves such execution plans for a query, i.e. if the query is to be executed again, the parse overhead can be avoided. If you use literals, this works only if the values are identical.<\/p>\n\n\n\n
Conversely, if you use bind variables, Oracle creates the execution plan for the query with the placeholders and saves it like that. This way, it does not matter if the query is later executed with different values: it is always compared with the query with the bind variables. The previously determined execution plan can thus be used again and again\u2014without parsing.<\/p>\n\n\n\n
How much of a difference does that really make? As the old Java application we were examining exclusively uses JDBC drivers, we wrote a small sample application that also only uses JDBC and submits identical queries both as a native query and by way of a prepared statement. When using prepared statements, JDBC takes care of transmitting the bind variables to Oracle. The specific queries in this context were based on the ones that the ADDM had flagged as problematic. For the tests, we executed several hundred queries with different values and against various Oracle instances; in effect, the prepared statements were always executed 10 times faster, and in some instances up to 100 times faster<\/strong>! We had not expected the difference to be this great, but then, this corresponds to the tests under [2]<\/a>. We then repeated the tests using JPA and EclipseLink, and the time response was on a level with that of the prepared statements.<\/p>\n\n\n\n
As a result, we definitely recommend modifying the Java application, or at least the relevant components, so as to use prepared statements. The necessary changes to the code are manageable, as the following example shows:<\/p>\n\n\n\n
<\/div>\n\n\n\n
    import java.sql.Connection;\n    import java.sql.Statement;\n    import java.sql.PreparedStatement;\n    ...\n    \/\/ 1. Query with literal as native query\n    Statement stmt = connection.createStatement();\n    stmt.executeQuery(\"select * from my_table where my_field = 123\");\n    \/\/ 2. Query with bind variable using a PreparedStatement\n    String query = \"select * from my_table where my_field = ?\";\n    PreparedStatement stmt2 = connection.prepareStatement(query);\n    stmt2.setInt(1, 123);\n    stmt2.executeQuery();<\/code><\/pre>\n\n\n\n
<\/div>\n\n\n\n
Cursor-sharing \u2013 Tuning the database<\/strong><\/h2>\n\n\n\n
Lastly, we would like to point out an option provided directly on the Oracle database itself, for example if it is not possible to modify the respective code. The analysis of the ADDM produced the following note:<\/p>\n\n\n\n
Alternatively, you may set the parameter \u201ccursor_sharing\u201d to \u201cforce\u201d.<\/em><\/p><\/blockquote>\n\n\n\n
Normally, only identical queries are treated identically, i.e. not parsed again, which is the advantage of using bind variables and\/or prepared statements. But if you set this parameter to \u201cforce\u201d, queries that only differ in the literals used are also treated as identical. That sounds like a quick win at first, making changes to the code unnecessary. However, Oracle selbst<\/a> advises against doing so (but without elaborating). If you are interested, you can find a more comprehensive description of the parameter and its advantages and disadvantages here<\/a>.<\/p>\n\n\n\n
<\/div>\n\n\n\n
Conclusion<\/h3>\n\n\n\n
Small changes to the code can help to noticeably improve the performance even of older Java applications that use many native queries\u2014at least if the database is an Oracle database. Switching to prepared statements also pays off, especially if the application frequently has to execute similar queries. We were not able to verify whether other DBMS present similar differences in performance with literals vs. bind variables, but it is conceivable.<\/p>\n\n\n\n
<\/div>\n\n\n\n
\n\n\n\n
<\/div>\n\n\n\n
See also:<\/p>\n\n\n\n
[1] More information on ADDM: Oracle 12c: Database tuning and monitoring<\/a> (only German)
[2] Details on the hard parse and its performance: Bind variables \u2013 The key to application performance<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
Generally speaking, native database queries in an application complicate its maintainability and the possibility to develop independently of a specific database. Within the framework of a performance analysis of an old Java application with an Oracle database, we discovered another aspect that constitutes an argument against using this kind of query: the performance compared to prepared statements in the context of an Oracle database.<\/p>\n","protected":false},"author":53,"featured_media":1127,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"advgb_blocks_editor_width":"","advgb_blocks_columns_visual_guide":"","footnotes":""},"categories":[12],"tags":[576,577,581,583,584,585,586,587,588,589,573,574],"topics":[],"class_list":["post-1109","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java","tag-native-queries","tag-prepared-statements","tag-cursor-sharing","tag-bind-variables","tag-application-performance","tag-differences-in-performance","tag-database","tag-database-requests","tag-literal-vs-bind-variable","tag-database-tuning","tag-oracle","tag-performance"],"acf":[],"yoast_head":"\nThe Dark Side of Parsing - ZEISS Digital Innovation Blog<\/title>\n<meta name=\"description\" content=\"Native database queries in an application complicate its maintainability and the possibility to develop independently of a specific database.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/the-dark-side-of-parsing\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"The Dark Side of Parsing - ZEISS Digital Innovation Blog\" \/>\n<meta property=\"og:description\" content=\"Native database queries in an application complicate its maintainability and the possibility to develop independently of a specific database.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/the-dark-side-of-parsing\/\" \/>\n<meta property=\"og:site_name\" content=\"Digital Innovation Blog\" \/>\n<meta property=\"article:published_time\" content=\"2016-02-22T09:55:49+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2020-09-25T11:45:28+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/wp-content\/uploads\/sites\/3\/2016\/02\/201602_cursor_sharing_en_fi.png\" \/>\n\t<meta property=\"og:image:width\" content=\"759\" \/>\n\t<meta property=\"og:image:height\" content=\"427\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"Andreas Post\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Andreas Post\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"4 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"WebPage\",\"@id\":\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/the-dark-side-of-parsing\/\",\"url\":\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/the-dark-side-of-parsing\/\",\"name\":\"The Dark Side of Parsing - ZEISS Digital Innovation Blog\",\"isPartOf\":{\"@id\":\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/the-dark-side-of-parsing\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/the-dark-side-of-parsing\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/wp-content\/uploads\/sites\/3\/2016\/02\/201602_cursor_sharing_en_fi.png\",\"datePublished\":\"2016-02-22T09:55:49+00:00\",\"dateModified\":\"2020-09-25T11:45:28+00:00\",\"author\":{\"@id\":\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/#\/schema\/person\/a2c27e1ce4804b57e7968b6c5df42852\"},\"description\":\"Native database queries in an application complicate its maintainability and the possibility to develop independently of a specific database.\",\"breadcrumb\":{\"@id\":\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/the-dark-side-of-parsing\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/the-dark-side-of-parsing\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/the-dark-side-of-parsing\/#primaryimage\",\"url\":\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/wp-content\/uploads\/sites\/3\/2016\/02\/201602_cursor_sharing_en_fi.png\",\"contentUrl\":\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/wp-content\/uploads\/sites\/3\/2016\/02\/201602_cursor_sharing_en_fi.png\",\"width\":759,\"height\":427},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/the-dark-side-of-parsing\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"The Dark Side of Parsing\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/#website\",\"url\":\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/\",\"name\":\"Digital Innovation Blog\",\"description\":\"\",\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Person\",\"@id\":\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/#\/schema\/person\/a2c27e1ce4804b57e7968b6c5df42852\",\"name\":\"Andreas Post\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/wp-content\/uploads\/sites\/3\/2020\/05\/post_andreas-150x150.jpg\",\"contentUrl\":\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/wp-content\/uploads\/sites\/3\/2020\/05\/post_andreas-150x150.jpg\",\"caption\":\"Andreas Post\"},\"description\":\"Andreas Post is software developer and team leader at ZEISS Digital Innovation since 2007. His focus is in the Java \/ Java EE environment with the specialist focus on developments in the fields of energy management and mobility solutions.\",\"url\":\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/author\/enandreaspost\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"The Dark Side of Parsing - ZEISS Digital Innovation Blog","description":"Native database queries in an application complicate its maintainability and the possibility to develop independently of a specific database.","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:\/\/blogs.zeiss.com\/digital-innovation\/en\/the-dark-side-of-parsing\/","og_locale":"en_US","og_type":"article","og_title":"The Dark Side of Parsing - ZEISS Digital Innovation Blog","og_description":"Native database queries in an application complicate its maintainability and the possibility to develop independently of a specific database.","og_url":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/the-dark-side-of-parsing\/","og_site_name":"Digital Innovation Blog","article_published_time":"2016-02-22T09:55:49+00:00","article_modified_time":"2020-09-25T11:45:28+00:00","og_image":[{"width":759,"height":427,"url":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/wp-content\/uploads\/sites\/3\/2016\/02\/201602_cursor_sharing_en_fi.png","type":"image\/png"}],"author":"Andreas Post","twitter_card":"summary_large_image","twitter_misc":{"Written by":"Andreas Post","Est. reading time":"4 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebPage","@id":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/the-dark-side-of-parsing\/","url":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/the-dark-side-of-parsing\/","name":"The Dark Side of Parsing - ZEISS Digital Innovation Blog","isPartOf":{"@id":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/#website"},"primaryImageOfPage":{"@id":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/the-dark-side-of-parsing\/#primaryimage"},"image":{"@id":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/the-dark-side-of-parsing\/#primaryimage"},"thumbnailUrl":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/wp-content\/uploads\/sites\/3\/2016\/02\/201602_cursor_sharing_en_fi.png","datePublished":"2016-02-22T09:55:49+00:00","dateModified":"2020-09-25T11:45:28+00:00","author":{"@id":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/#\/schema\/person\/a2c27e1ce4804b57e7968b6c5df42852"},"description":"Native database queries in an application complicate its maintainability and the possibility to develop independently of a specific database.","breadcrumb":{"@id":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/the-dark-side-of-parsing\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/blogs.zeiss.com\/digital-innovation\/en\/the-dark-side-of-parsing\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/the-dark-side-of-parsing\/#primaryimage","url":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/wp-content\/uploads\/sites\/3\/2016\/02\/201602_cursor_sharing_en_fi.png","contentUrl":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/wp-content\/uploads\/sites\/3\/2016\/02\/201602_cursor_sharing_en_fi.png","width":759,"height":427},{"@type":"BreadcrumbList","@id":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/the-dark-side-of-parsing\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/"},{"@type":"ListItem","position":2,"name":"The Dark Side of Parsing"}]},{"@type":"WebSite","@id":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/#website","url":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/","name":"Digital Innovation Blog","description":"","potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Person","@id":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/#\/schema\/person\/a2c27e1ce4804b57e7968b6c5df42852","name":"Andreas Post","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/#\/schema\/person\/image\/","url":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/wp-content\/uploads\/sites\/3\/2020\/05\/post_andreas-150x150.jpg","contentUrl":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/wp-content\/uploads\/sites\/3\/2020\/05\/post_andreas-150x150.jpg","caption":"Andreas Post"},"description":"Andreas Post is software developer and team leader at ZEISS Digital Innovation since 2007. His focus is in the Java \/ Java EE environment with the specialist focus on developments in the fields of energy management and mobility solutions.","url":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/author\/enandreaspost\/"}]}},"author_meta":{"display_name":"Andreas Post","author_link":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/author\/enandreaspost\/"},"featured_img":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/wp-content\/uploads\/sites\/3\/2016\/02\/201602_cursor_sharing_en_fi-600x338.png","coauthors":[],"tax_additional":{"categories":{"linked":["<a href=\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/category\/java\/\" class=\"advgb-post-tax-term\">Java<\/a>"],"unlinked":["<span class=\"advgb-post-tax-term\">Java<\/span>"]},"tags":{"linked":["<a href=\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/category\/java\/\" class=\"advgb-post-tax-term\">Native Queries<\/a>","<a href=\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/category\/java\/\" class=\"advgb-post-tax-term\">Prepared Statements<\/a>","<a href=\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/category\/java\/\" class=\"advgb-post-tax-term\">Cursor Sharing<\/a>","<a href=\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/category\/java\/\" class=\"advgb-post-tax-term\">Bind variables<\/a>","<a href=\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/category\/java\/\" class=\"advgb-post-tax-term\">application performance<\/a>","<a href=\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/category\/java\/\" class=\"advgb-post-tax-term\">differences in performance<\/a>","<a href=\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/category\/java\/\" class=\"advgb-post-tax-term\">database<\/a>","<a href=\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/category\/java\/\" class=\"advgb-post-tax-term\">database requests<\/a>","<a href=\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/category\/java\/\" class=\"advgb-post-tax-term\">literal vs. bind variable<\/a>","<a href=\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/category\/java\/\" class=\"advgb-post-tax-term\">database tuning<\/a>","<a href=\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/category\/java\/\" class=\"advgb-post-tax-term\">Oracle<\/a>","<a href=\"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/category\/java\/\" class=\"advgb-post-tax-term\">Performance<\/a>"],"unlinked":["<span class=\"advgb-post-tax-term\">Native Queries<\/span>","<span class=\"advgb-post-tax-term\">Prepared Statements<\/span>","<span class=\"advgb-post-tax-term\">Cursor Sharing<\/span>","<span class=\"advgb-post-tax-term\">Bind variables<\/span>","<span class=\"advgb-post-tax-term\">application performance<\/span>","<span class=\"advgb-post-tax-term\">differences in performance<\/span>","<span class=\"advgb-post-tax-term\">database<\/span>","<span class=\"advgb-post-tax-term\">database requests<\/span>","<span class=\"advgb-post-tax-term\">literal vs. bind variable<\/span>","<span class=\"advgb-post-tax-term\">database tuning<\/span>","<span class=\"advgb-post-tax-term\">Oracle<\/span>","<span class=\"advgb-post-tax-term\">Performance<\/span>"]}},"comment_count":"0","relative_dates":{"created":"Posted 10 years ago","modified":"Updated 6 years ago"},"absolute_dates":{"created":"Posted on February 22, 2016","modified":"Updated on September 25, 2020"},"absolute_dates_time":{"created":"Posted on February 22, 2016 9:55 am","modified":"Updated on September 25, 2020 11:45 am"},"featured_img_caption":"","series_order":"","_links":{"self":[{"href":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/wp-json\/wp\/v2\/posts\/1109","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/wp-json\/wp\/v2\/users\/53"}],"replies":[{"embeddable":true,"href":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/wp-json\/wp\/v2\/comments?post=1109"}],"version-history":[{"count":5,"href":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/wp-json\/wp\/v2\/posts\/1109\/revisions"}],"predecessor-version":[{"id":1129,"href":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/wp-json\/wp\/v2\/posts\/1109\/revisions\/1129"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/wp-json\/wp\/v2\/media\/1127"}],"wp:attachment":[{"href":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/wp-json\/wp\/v2\/media?parent=1109"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/wp-json\/wp\/v2\/categories?post=1109"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/wp-json\/wp\/v2\/tags?post=1109"},{"taxonomy":"topics","embeddable":true,"href":"https:\/\/blogs.zeiss.com\/digital-innovation\/en\/wp-json\/wp\/v2\/topics?post=1109"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}