{"id":16788,"date":"2026-09-19T11:11:20","date_gmt":"2026-09-19T11:11:20","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=16788"},"modified":"2026-09-19T11:11:20","modified_gmt":"2026-09-19T11:11:20","slug":"databricks-certified-data-engineer-associate-test-questions-and-exam-dumps-part19-q361-380","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/databricks-certified-data-engineer-associate-test-questions-and-exam-dumps-part19-q361-380\/","title":{"rendered":"Databricks Certified Data Engineer Associate Test Questions and Exam Dumps Part19 Q361-380"},"content":{"rendered":"

<\/h1>\n

View Full <\/b>Databricks Certified Data Engineer Associate Exam Dumps<\/b><\/a> and Practice Test Dumps.<\/b><\/h2>\n

Question 361<\/b><\/h3>\n

Which SQL command can be used to view the properties currently configured for a Delta table?<\/b><\/p>\n

    \n
  1. SHOW TBLPROPERTIES<\/span><\/li>\n
  2. SHOW DATABASES<\/span><\/li>\n
  3. SHOW FUNCTIONS<\/span><\/li>\n
  4. SHOW COLUMNS<\/span><\/li>\n<\/ol>\n

    Correct Answer: 1<\/b><\/p>\n

    Explanation<\/b><\/p>\n

    The <\/span>SHOW TBLPROPERTIES<\/span> command displays the properties associated with a table, including properties configured for Delta Lake behavior. Table properties can control or describe specific table settings and are useful when troubleshooting or verifying configuration. <\/span>SHOW DATABASES<\/span> lists catalogs or databases, <\/span>SHOW FUNCTIONS<\/span> lists available functions, and <\/span>SHOW COLUMNS<\/span> provides column information. Data engineers can use <\/span>SHOW TBLPROPERTIES<\/span> when they need to inspect configuration values without modifying the underlying table.<\/span><\/p>\n

    Question 362<\/b><\/h3>\n

    A data engineer wants to enable a specific Delta Lake feature through a table property. Which command is appropriate for modifying an existing table’s properties?<\/b><\/p>\n

      \n
    1. ALTER TABLE table_name ADD COLUMN property_name<\/span><\/li>\n
    2. ALTER TABLE table_name SET TBLPROPERTIES (‘property_name’ = ‘value’)<\/span><\/li>\n
    3. UPDATE table_name SET TBLPROPERTIES = ‘value’<\/span><\/li>\n
    4. MODIFY TABLE table_name PROPERTY property_name = ‘value’<\/span><\/li>\n<\/ol>\n

      Correct Answer: 2<\/b><\/p>\n

      Explanation<\/b><\/p>\n

      ALTER TABLE … SET TBLPROPERTIES<\/span> is used to add or modify properties associated with an existing Delta table. The property is specified as a key-value pair, allowing administrators or data engineers to configure supported Delta behavior. The other commands either modify table data or use syntax that is not valid for setting Delta table properties. Because table properties can affect table behavior, they should be changed deliberately and tested appropriately before being applied to production workloads.<\/span><\/p>\n

      Question 363<\/b><\/h3>\n

      A Delta table contains an array column named <\/b>items<\/b>. Each row may contain multiple product identifiers. The engineer needs one output row for every item in the array. Which function is most appropriate?<\/b><\/p>\n

        \n
      1. concat()<\/span><\/li>\n
      2. collect_list()<\/span><\/li>\n
      3. explode()<\/span><\/li>\n
      4. flatten()<\/span><\/li>\n<\/ol>\n

        Correct Answer: 3<\/b><\/p>\n

        Explanation<\/b><\/p>\n

        The <\/span>explode()<\/span> function converts each element of an array or map into a separate output row. For example, if one record contains three product identifiers in an array, <\/span>explode(items)<\/span> can produce three rows associated with that original record. This is useful when nested data needs to be transformed into a relational structure for filtering, joining, or aggregation. <\/span>collect_list()<\/span> performs the opposite type of aggregation by collecting values into an array, while <\/span>concat()<\/span> combines values.<\/span><\/p>\n

        Question 364<\/b><\/h3>\n

        A JSON column contains customer information such as name, city, and membership level. The engineer needs to convert the JSON string into structured columns that can be queried individually. Which Spark SQL function should be used?<\/b><\/p>\n

          \n
        1. to_json()<\/span><\/li>\n
        2. explode()<\/span><\/li>\n
        3. concat()<\/span><\/li>\n
        4. from_json()<\/span><\/li>\n<\/ol>\n

          Correct Answer: 4<\/b><\/p>\n

          Explanation<\/b><\/p>\n

          The <\/span>from_json()<\/span> function parses a JSON-formatted string into a structured value using a supplied schema. This allows individual fields within the JSON document to be referenced as columns or nested fields in Spark transformations. For example, customer name and membership level can be extracted after parsing the JSON string. <\/span>to_json()<\/span> performs the reverse operation by converting structured data into JSON text. <\/span>explode()<\/span> expands arrays or maps, while <\/span>concat()<\/span> combines strings or other compatible values.<\/span><\/p>\n

          Question 365<\/b><\/h3>\n

          A data engineer wants to create a Delta table directly from the results of a SQL query. Which approach is appropriate?<\/b><\/p>\n

            \n
          1. CREATE TABLE new_table AS SELECT …<\/span><\/li>\n
          2. CREATE TABLE new_table USING JSON AS SELECT …<\/span><\/li>\n
          3. CREATE VIEW new_table AS TABLE …<\/span><\/li>\n
          4. INSERT TABLE new_table FROM SELECT …<\/span><\/li>\n<\/ol>\n

            Correct Answer: 1<\/b><\/p>\n

            Explanation<\/b><\/p>\n

            CREATE TABLE … AS SELECT<\/span>, commonly called CTAS, creates a table using the results returned by a query. In Databricks, the resulting table can be created as a Delta table when Delta is the configured or specified format. CTAS is useful when an engineer wants to create a new table from transformed or filtered data without separately creating the table schema first. The other choices either use invalid syntax or create different database objects rather than a table from a query result.<\/span><\/p>\n

            Question 366<\/b><\/h3>\n

            A data engineer needs to create a new table containing only selected records from an existing Delta table. Which SQL statement is most suitable?<\/b><\/p>\n

              \n
            1. CREATE VIEW new_table AS SELECT …<\/span><\/li>\n
            2. CREATE TABLE new_table AS SELECT * FROM source_table WHERE …<\/span><\/li>\n
            3. ALTER TABLE source_table FILTER …<\/span><\/li>\n
            4. UPDATE TABLE new_table FROM source_table …<\/span><\/li>\n<\/ol>\n

              Correct Answer: 2<\/b><\/p>\n

              Explanation<\/b><\/p>\n

              A CTAS statement can create a new table from a filtered query result. For example, <\/span>CREATE TABLE new_table AS SELECT * FROM source_table WHERE status = ‘active’<\/span> creates a separate table containing only the records that satisfy the filter. This is different from creating a view, because the new table stores its own data rather than simply representing a saved query. <\/span>ALTER TABLE<\/span> does not provide a general filtering operation, and the proposed <\/span>UPDATE TABLE<\/span> syntax is invalid.<\/span><\/p>\n

              Question 367<\/b><\/h3>\n

              A SQL query calculates total sales for each customer. The engineer wants to return only customers whose total sales exceed 10,000. Which clause should filter the grouped results?<\/b><\/p>\n

                \n
              1. WHERE<\/span><\/li>\n
              2. ORDER BY<\/span><\/li>\n
              3. HAVING<\/span><\/li>\n
              4. LIMIT<\/span><\/li>\n<\/ol>\n

                Correct Answer: 3<\/b><\/p>\n

                Explanation<\/b><\/p>\n

                The <\/span>HAVING<\/span> clause filters results after grouping and aggregation have been performed. In this scenario, the query might group records by customer and calculate <\/span>SUM(sales)<\/span>, then use <\/span>HAVING SUM(sales) > 10000<\/span> to retain only qualifying customers. <\/span>WHERE<\/span> filters individual rows before grouping and therefore is not the appropriate clause for filtering an aggregate result. <\/span>ORDER BY<\/span> sorts the final results, while <\/span>LIMIT<\/span> restricts the number of rows returned without evaluating the aggregate condition.<\/span><\/p>\n

                Question 368<\/b><\/h3>\n

                A table contains NULL values in a <\/b>phone_number<\/b> column. The engineer wants to display the customer’s alternate phone number whenever the primary phone number is NULL. Which SQL function is appropriate?<\/b><\/p>\n

                  \n
                1. NULLIF()<\/span><\/li>\n
                2. ISNULL()<\/span><\/li>\n
                3. NVL2()<\/span><\/li>\n
                4. COALESCE()<\/span><\/li>\n<\/ol>\n

                  Correct Answer: 4<\/b><\/p>\n

                  Explanation<\/b><\/p>\n

                  COALESCE()<\/span> returns the first non-NULL expression from the values provided. For example, <\/span>COALESCE(phone_number, alternate_phone)<\/span> returns the primary phone number when it exists and the alternate number when the primary value is NULL. This makes it useful for implementing fallback logic when datasets contain missing values. <\/span>NULLIF()<\/span> returns NULL when two expressions are equal, while the other functions have different null-handling behavior. <\/span>COALESCE()<\/span> is particularly convenient when more than two possible fallback values are available.<\/span><\/p>\n

                  Question 369<\/b><\/h3>\n

                  A data engineer needs to categorize orders as <\/b>High<\/b>, <\/b>Medium<\/b>, or <\/b>Low<\/b> based on their total amount. Which SQL construct is most appropriate?<\/b><\/p>\n

                    \n
                  1. CASE WHEN<\/span><\/li>\n
                  2. UNION ALL<\/span><\/li>\n
                  3. HAVING<\/span><\/li>\n
                  4. DISTINCT<\/span><\/li>\n<\/ol>\n

                    Correct Answer: 1<\/b><\/p>\n

                    Explanation<\/b><\/p>\n

                    The <\/span>CASE WHEN<\/span> expression allows SQL queries to return different values based on specified conditions. An engineer can use it to classify orders according to their amount, such as returning <\/span>High<\/span> for amounts above a threshold, <\/span>Medium<\/span> for intermediate values, and <\/span>Low<\/span> for smaller amounts. <\/span>UNION ALL<\/span> combines query results, <\/span>HAVING<\/span> filters grouped results, and <\/span>DISTINCT<\/span> removes duplicate rows. <\/span>CASE WHEN<\/span> is therefore the appropriate construct for creating conditional categories within query results.<\/span><\/p>\n

                    Question 370<\/b><\/h3>\n

                    Which statement correctly describes the difference between <\/b>UNION<\/b> and <\/b>UNION ALL<\/b> in SQL?<\/b><\/p>\n

                      \n
                    1. UNION always preserves duplicates, while UNION ALL removes them.<\/span><\/li>\n
                    2. UNION removes duplicate rows, while UNION ALL retains them.<\/span><\/li>\n
                    3. UNION sorts every result, while UNION ALL never returns rows.<\/span><\/li>\n
                    4. UNION works only with Delta tables, while UNION ALL works only with views.<\/span><\/li>\n<\/ol>\n

                      Correct Answer: 2<\/b><\/p>\n

                      Explanation<\/b><\/p>\n

                      UNION<\/span> combines the results of compatible queries and removes duplicate rows from the combined result. <\/span>UNION ALL<\/span> also combines query results but preserves duplicate rows. Because duplicate removal requires additional processing, <\/span>UNION ALL<\/span> can be preferable when duplicates are meaningful or when the input datasets are already known to be distinct. Both operations can work with compatible query results from tables, views, or other supported relations. The choice depends on whether duplicate records should remain in the final dataset.<\/span><\/p>\n

                      Question 371<\/b><\/h3>\n

                      A data engineer wants to count the number of unique customers who placed orders. Which SQL expression should be used?<\/b><\/p>\n

                        \n
                      1. COUNT(customer_id)<\/span><\/li>\n
                      2. SUM(customer_id)<\/span><\/li>\n
                      3. COUNT(DISTINCT customer_id)<\/span><\/li>\n
                      4. DISTINCT(COUNT(customer_id))<\/span><\/li>\n<\/ol>\n

                        Correct Answer: 3<\/b><\/p>\n

                        Explanation<\/b><\/p>\n

                        COUNT(DISTINCT customer_id)<\/span> counts each unique non-NULL customer identifier once. This is different from <\/span>COUNT(customer_id)<\/span>, which counts every non-NULL occurrence and may count the same customer multiple times when the customer has placed several orders. <\/span>SUM()<\/span> is designed for numeric aggregation rather than counting unique identifiers. Using <\/span>DISTINCT<\/span> inside <\/span>COUNT<\/span> directly expresses the requirement to determine the number of different customers represented in the dataset.<\/span><\/p>\n

                        Question 372<\/b><\/h3>\n

                        A data engineer wants to create a table whose columns are generated from a query while explicitly storing the result in Delta format. Which statement is appropriate?<\/b><\/p>\n

                          \n
                        1. CREATE VIEW sales_table AS SELECT …<\/span><\/li>\n
                        2. CREATE TABLE sales_table AS VIEW …<\/span><\/li>\n
                        3. CREATE TABLE sales_table USING PARQUET AS SELECT …<\/span><\/li>\n
                        4. CREATE TABLE sales_table USING DELTA AS SELECT …<\/span><\/li>\n<\/ol>\n

                          Correct Answer: 4<\/b><\/p>\n

                          Explanation<\/b><\/p>\n

                          CREATE TABLE … USING DELTA AS SELECT<\/span> explicitly specifies Delta as the storage format while creating a table from query results. This combines the CTAS pattern with an explicit format declaration. It is useful when the engineer wants to make the table format clear and ensure that the created table uses Delta Lake capabilities. A view does not materialize the query result as a stored table, while specifying another format such as Parquet would create a table using that format instead of Delta.<\/span><\/p>\n

                          Question 373<\/b><\/h3>\n

                          A data engineer needs to replace an existing table definition with the result of a new query while keeping the operation concise. Which SQL pattern is designed for this purpose?<\/b><\/p>\n

                            \n
                          1. CREATE OR REPLACE TABLE<\/span><\/li>\n
                          2. SHOW OR REPLACE TABLE<\/span><\/li>\n
                          3. ALTER OR CREATE TABLE<\/span><\/li>\n
                          4. UPDATE OR CREATE TABLE<\/span><\/li>\n<\/ol>\n

                            Correct Answer: 1<\/b><\/p>\n

                            Explanation<\/b><\/p>\n

                            CREATE OR REPLACE TABLE<\/span> provides a concise way to create a table if it does not exist or replace an existing table definition and data according to the supported operation. This pattern can simplify pipelines that repeatedly produce a complete table from a query or transformation. It should be used carefully because replacing a table can change its existing contents and metadata. The other listed statements are not valid SQL patterns for replacing a table in this manner.<\/span><\/p>\n

                            Question 374<\/b><\/h3>\n

                            A data engineer needs to add a new column named <\/b>email<\/b> to an existing Delta table without removing its existing columns or rows. Which statement should be used?<\/b><\/p>\n

                              \n
                            1. UPDATE TABLE customers ADD email STRING<\/span><\/li>\n
                            2. ALTER TABLE customers ADD COLUMNS (email STRING)<\/span><\/li>\n
                            3. INSERT TABLE customers ADD email STRING<\/span><\/li>\n
                            4. MODIFY TABLE customers COLUMN email STRING<\/span><\/li>\n<\/ol>\n

                              Correct Answer: 2<\/b><\/p>\n

                              Explanation<\/b><\/p>\n

                              ALTER TABLE … ADD COLUMNS<\/span> adds one or more columns to an existing table while preserving the existing table data. For example, <\/span>ALTER TABLE customers ADD COLUMNS (email STRING)<\/span> adds an <\/span>email<\/span> column with the specified data type. Existing rows will have NULL for the new column unless values are subsequently populated. The other options use invalid SQL syntax for adding columns. This operation is useful when the schema must evolve to accommodate a newly required attribute.<\/span><\/p>\n

                              Question 375<\/b><\/h3>\n

                              A data engineer receives customer records where some rows have missing values in several fields. Which approach allows multiple fallback values to be checked from left to right?<\/b><\/p>\n

                                \n
                              1. CASE ONLY<\/span><\/li>\n
                              2. NULLIF()<\/span><\/li>\n
                              3. COALESCE()<\/span><\/li>\n
                              4. DISTINCT<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 3<\/b><\/p>\n

                                Explanation<\/b><\/p>\n

                                COALESCE()<\/span> accepts multiple expressions and returns the first expression that is not NULL. For example, <\/span>COALESCE(primary_email, secondary_email, default_email)<\/span> checks the values from left to right and returns the first available value. This makes the function useful for cleaning datasets with several possible sources for the same attribute. <\/span>NULLIF()<\/span> serves a different purpose by returning NULL when two expressions are equal. <\/span>DISTINCT<\/span> removes duplicate results rather than selecting fallback values from multiple expressions.<\/span><\/p>\n

                                Question 376<\/b><\/h3>\n

                                A source column contains values such as <\/b>active<\/b>, <\/b>inactive<\/b>, and <\/b>pending<\/b>. The engineer needs to convert them into numeric status codes within a query. Which approach is most suitable?<\/b><\/p>\n

                                  \n
                                1. UNION ALL<\/span><\/li>\n
                                2. HAVING<\/span><\/li>\n
                                3. COALESCE only<\/span><\/li>\n
                                4. CASE WHEN<\/span><\/li>\n<\/ol>\n

                                  Correct Answer: 4<\/b><\/p>\n

                                  Explanation<\/b><\/p>\n

                                  CASE WHEN<\/span> is appropriate for mapping categorical values to other representations. An engineer can define conditions such as <\/span>WHEN status = ‘active’ THEN 1<\/span>, <\/span>WHEN status = ‘inactive’ THEN 2<\/span>, and so on. This creates a derived numeric status code directly in the query. <\/span>UNION ALL<\/span> combines separate result sets rather than mapping values, <\/span>HAVING<\/span> filters aggregated results, and <\/span>COALESCE()<\/span> handles NULL fallback values. Therefore, conditional logic with <\/span>CASE WHEN<\/span> is the suitable approach.<\/span><\/p>\n

                                  Question 377<\/b><\/h3>\n

                                  Which SQL clause should be used when an engineer wants to remove duplicate rows from the result of a query?<\/b><\/p>\n

                                    \n
                                  1. DISTINCT<\/span><\/li>\n
                                  2. HAVING<\/span><\/li>\n
                                  3. LIMIT<\/span><\/li>\n
                                  4. GROUP FILTER<\/span><\/li>\n<\/ol>\n

                                    Correct Answer: 1<\/b><\/p>\n

                                    Explanation<\/b><\/p>\n

                                    The <\/span>DISTINCT<\/span> keyword removes duplicate combinations of the selected columns from a query result. For example, <\/span>SELECT DISTINCT city FROM customers<\/span> returns each city only once. This is useful when duplicate rows exist in the source or when the desired output should contain unique values. <\/span>HAVING<\/span> filters groups after aggregation, while <\/span>LIMIT<\/span> controls the number of rows returned. <\/span>GROUP FILTER<\/span> is not a standard SQL clause for removing duplicates. <\/span>DISTINCT<\/span> directly expresses the requirement for unique query results.<\/span><\/p>\n

                                    Question 378<\/b><\/h3>\n

                                    A data engineer wants to return orders placed during a specific date range before performing a grouping operation. Which clause should normally be used to filter the individual order records?<\/b><\/p>\n

                                      \n
                                    1. HAVING<\/span><\/li>\n
                                    2. WHERE<\/span><\/li>\n
                                    3. ORDER BY<\/span><\/li>\n
                                    4. LIMIT<\/span><\/li>\n<\/ol>\n

                                      Correct Answer: 2<\/b><\/p>\n

                                      Explanation<\/b><\/p>\n

                                      The <\/span>WHERE<\/span> clause filters individual source rows before grouping and aggregation take place. For a date-range requirement, the engineer can use a condition such as <\/span>WHERE order_date >= … AND order_date < …<\/span>. Filtering early can also reduce the amount of data that later aggregation needs to process. <\/span>HAVING<\/span> is intended for filtering grouped or aggregated results, while <\/span>ORDER BY<\/span> sorts rows and <\/span>LIMIT<\/span> restricts the number of returned rows. Therefore, <\/span>WHERE<\/span> is the appropriate clause for row-level date filtering.<\/span><\/p>\n

                                      Question 379<\/b><\/h3>\n

                                      A Delta table stores customer events in a nested JSON structure. The engineer first parses the JSON and then needs to access the nested <\/b>address.city<\/b> field. What is the key benefit of parsing the JSON into a structured type?<\/b><\/p>\n

                                        \n
                                      1. It automatically deletes invalid records.<\/span><\/li>\n
                                      2. It converts all nested fields into separate physical tables.<\/span><\/li>\n
                                      3. It allows nested fields to be referenced as structured attributes.<\/span><\/li>\n
                                      4. It permanently converts every JSON document into plain text.<\/span><\/li>\n<\/ol>\n

                                        Correct Answer: 3<\/b><\/p>\n

                                        Explanation<\/b><\/p>\n

                                        Parsing JSON into a structured type allows Spark to understand the document’s schema and lets engineers reference nested attributes directly. For example, after parsing a customer JSON object, a field such as <\/span>address.city<\/span> can be selected or used in transformations. This is different from simply storing JSON as an unparsed string, where field-level access requires additional parsing. Structured data can therefore be filtered, selected, joined, and transformed more naturally within Spark and SQL operations.<\/span><\/p>\n

                                        Question 380<\/b><\/h3>\n

                                        A pipeline needs to combine the results of two queries while preserving duplicate records because each occurrence represents a separate event. Which operation should the engineer use?<\/b><\/p>\n

                                          \n
                                        1. UNION<\/span><\/li>\n
                                        2. DISTINCT<\/span><\/li>\n
                                        3. GROUP BY<\/span><\/li>\n
                                        4. UNION ALL<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 4<\/b><\/p>\n

                                          Explanation<\/b><\/p>\n

                                          UNION ALL<\/span> combines the results of two compatible queries while preserving duplicate rows. This is important when each occurrence represents a meaningful event and removing duplicates would incorrectly reduce the event count. In contrast, <\/span>UNION<\/span> removes duplicate rows from the combined result. <\/span>DISTINCT<\/span> also removes duplicates from a query result, while <\/span>GROUP BY<\/span> creates groups for aggregation or other grouped operations. When duplicate event records are intentionally meaningful, <\/span>UNION ALL<\/span> is the appropriate operation.<\/span><\/p>\n

                                           <\/p>\n","protected":false},"excerpt":{"rendered":"

                                          View Full Databricks Certified Data Engineer Associate Exam Dumps and Practice Test Dumps. Question 361 Which SQL command can be used to view the properties currently configured for a Delta table? SHOW TBLPROPERTIES SHOW DATABASES SHOW FUNCTIONS SHOW COLUMNS Correct Answer: 1 Explanation The SHOW TBLPROPERTIES command displays the properties associated with a table, including […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[1648,1647],"tags":[],"_links":{"self":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/16788"}],"collection":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/comments?post=16788"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/16788\/revisions"}],"predecessor-version":[{"id":16791,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/16788\/revisions\/16791"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=16788"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=16788"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=16788"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}