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

<\/h1>\n

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

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

A data engineer wants to inspect all configuration properties of a Delta table, including properties not shown by the basic table description. Which command is most appropriate?<\/b><\/p>\n

    \n
  1. DESCRIBE TABLE EXTENDED<\/span><\/li>\n
  2. SHOW DATABASES<\/span><\/li>\n
  3. SHOW FUNCTIONS<\/span><\/li>\n
  4. DESCRIBE HISTORY<\/span><\/li>\n<\/ol>\n

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

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

    DESCRIBE TABLE EXTENDED<\/span> provides detailed metadata about a table beyond basic column information. Depending on the table and environment, the output can include additional metadata and properties that help engineers understand how the table is defined. <\/span>SHOW DATABASES<\/span> lists databases or schemas, while <\/span>SHOW FUNCTIONS<\/span> lists available functions. <\/span>DESCRIBE HISTORY<\/span> focuses on the Delta transaction history rather than the complete table metadata. Engineers can use the extended description when investigating table definitions, metadata, and configuration details.<\/span><\/p>\n

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

    A data engineer needs to inspect the schema and metadata of a table before writing a transformation against it. Which statement is appropriate?<\/b><\/p>\n

      \n
    1. SHOW TBLPROPERTIES<\/span><\/li>\n
    2. DESCRIBE TABLE<\/span><\/li>\n
    3. VACUUM TABLE<\/span><\/li>\n
    4. OPTIMIZE TABLE<\/span><\/li>\n<\/ol>\n

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

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

      DESCRIBE TABLE<\/span> provides information about a table’s columns, including column names and data types, and can provide additional table information depending on the syntax used. This makes it useful before developing transformations because the engineer can confirm the available fields and their types. <\/span>SHOW TBLPROPERTIES<\/span> focuses specifically on table properties, while <\/span>VACUUM<\/span> removes eligible old files and <\/span>OPTIMIZE<\/span> improves file layout. Neither maintenance command is intended for inspecting a table schema.<\/span><\/p>\n

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

      A pipeline receives records containing an array of product categories. The engineer wants to create one row for each category while retaining the original order identifier. Which operation is appropriate?<\/b><\/p>\n

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

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

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

        The <\/span>explode()<\/span> function expands an array so that each element becomes a separate row. If an order contains several product categories, applying <\/span>explode()<\/span> to the category array produces one output row per category while other columns, such as the order identifier, remain associated with each generated row. <\/span>collect_list()<\/span> aggregates values into an array, while <\/span>array_join()<\/span> and <\/span>concat_ws()<\/span> convert array elements into a string representation. Therefore, <\/span>explode()<\/span> is the appropriate operation for normalizing array-based records.<\/span><\/p>\n

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

        A data engineer wants to convert a structured Spark column into a JSON string before sending the data to an external system that expects JSON text. Which function should be used?<\/b><\/p>\n

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

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

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

          The <\/span>to_json()<\/span> function converts a struct, map, or other supported complex value into a JSON-formatted string. This is useful when a downstream application or external interface expects JSON text rather than Spark’s structured representation. <\/span>from_json()<\/span> performs the opposite operation by parsing JSON text into a structured value. <\/span>explode()<\/span> expands arrays or maps into rows, while <\/span>parse_json()<\/span> is not the appropriate standard Spark SQL function for this transformation. Using <\/span>to_json()<\/span> preserves the structured information in JSON format.<\/span><\/p>\n

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

          A data engineer wants to make a Delta table automatically expire records after a defined period by using a table configuration rather than manually deleting individual rows. What should the engineer investigate first?<\/b><\/p>\n

            \n
          1. Delta table properties and supported retention-related configuration<\/span><\/li>\n
          2. UNION ALL<\/span><\/li>\n
          3. Window functions<\/span><\/li>\n
          4. Temporary views<\/span><\/li>\n<\/ol>\n

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

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

            Delta Lake provides table properties that can influence certain table behaviors, including supported retention-related settings. When implementing automated data-retention requirements, engineers should first review the supported Delta configuration and understand its effect before changing production settings. Retention configuration should not be confused with deleting individual rows through SQL. <\/span>UNION ALL<\/span> combines query results, window functions perform analytical calculations, and temporary views provide session-scoped query abstractions. Retention settings should also be considered alongside governance requirements and any operational need to recover older data.<\/span><\/p>\n

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

            A company wants to maintain a reusable SQL definition for a query but does not want to store a separate physical copy of the query results. What should the engineer create?<\/b><\/p>\n

              \n
            1. A managed table<\/span><\/li>\n
            2. A view<\/span><\/li>\n
            3. A Delta clone<\/span><\/li>\n
            4. A materialized table<\/span><\/li>\n<\/ol>\n

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

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

              A view stores a query definition rather than maintaining an independent physical copy of the underlying query results in the same way a table does. When users query the view, the underlying query is evaluated against its source data according to the view definition. This makes views useful for reusable SQL logic, abstraction, and controlled access to selected columns or rows. A managed table stores data, while a clone creates a table based on another table. The materialized result behavior is different from a standard view.<\/span><\/p>\n

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

              A data engineer needs to insert the results of a SELECT query into an existing Delta table. Which SQL operation is designed for this task?<\/b><\/p>\n

                \n
              1. CREATE VIEW<\/span><\/li>\n
              2. ALTER TABLE<\/span><\/li>\n
              3. INSERT INTO<\/span><\/li>\n
              4. DESCRIBE TABLE<\/span><\/li>\n<\/ol>\n

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

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

                INSERT INTO<\/span> adds rows produced by a query or specified values to an existing table. For example, <\/span>INSERT INTO target_table SELECT … FROM source_table<\/span> can transfer compatible records from one table into another. The target table must have a compatible schema for the inserted data. <\/span>CREATE VIEW<\/span> creates a query abstraction rather than inserting data, <\/span>ALTER TABLE<\/span> changes table metadata or structure, and <\/span>DESCRIBE TABLE<\/span> only displays metadata. Therefore, <\/span>INSERT INTO<\/span> is the appropriate operation for adding query results.<\/span><\/p>\n

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

                A data engineer needs to remove rows from a Delta table that match a specific business condition. Which SQL statement should be used?<\/b><\/p>\n

                  \n
                1. DROP TABLE<\/span><\/li>\n
                2. TRUNCATE TABLE<\/span><\/li>\n
                3. DELETE FROM<\/span><\/li>\n
                4. REMOVE ROWS<\/span><\/li>\n<\/ol>\n

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

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

                  The appropriate SQL statement for removing selected records from a Delta table is <\/span>DELETE FROM … WHERE<\/span>. For example, an engineer can remove records matching a particular status or date condition without deleting the entire table. <\/span>DROP TABLE<\/span> removes the table itself, while <\/span>TRUNCATE TABLE<\/span> removes all rows rather than applying a row-level condition. <\/span>REMOVE ROWS<\/span> is not valid SQL syntax for this purpose. Delta Lake records data modifications transactionally, allowing table operations to remain consistent.<\/span><\/p>\n

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

                  A pipeline processes event data where a timestamp column contains both date and time information. The engineer wants to group events by hour regardless of the minute and second values. Which function is useful?<\/b><\/p>\n

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

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

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

                    The <\/span>date_trunc()<\/span> function can truncate a timestamp to a specified time unit, such as hour, day, month, or year. Using an hourly truncation allows events occurring within the same hour to be grouped under the same timestamp boundary. This is useful for time-based aggregations and reporting. <\/span>explode()<\/span> handles nested arrays or maps, <\/span>collect_set()<\/span> creates a set of distinct aggregated values, and <\/span>concat()<\/span> combines expressions. Therefore, <\/span>date_trunc()<\/span> directly addresses the requirement to normalize timestamps to hourly boundaries.<\/span><\/p>\n

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

                    A data engineer wants the current timestamp generated during query execution so that newly created records can include an ingestion timestamp. Which function should be used?<\/b><\/p>\n

                      \n
                    1. current_date()<\/span><\/li>\n
                    2. current_timestamp()<\/span><\/li>\n
                    3. date_trunc()<\/span><\/li>\n
                    4. to_date()<\/span><\/li>\n<\/ol>\n

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

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

                      current_timestamp()<\/span> returns the current timestamp and can be used to populate an ingestion, processing, or audit timestamp in a transformation. Unlike <\/span>current_date()<\/span>, which returns only the date, <\/span>current_timestamp()<\/span> includes both date and time information. <\/span>date_trunc()<\/span> changes the precision of an existing timestamp, while <\/span>to_date()<\/span> converts a value to a date representation. Adding a processing timestamp can help data engineers track when records were processed or loaded into a pipeline.<\/span><\/p>\n

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

                      A SQL query should return all departments whose average employee salary is greater than 100,000. Which query pattern correctly applies the condition to the aggregate result?<\/b><\/p>\n

                        \n
                      1. SELECT department, AVG(salary) FROM employees GROUP BY department HAVING AVG(salary) > 100000<\/span><\/li>\n
                      2. SELECT department, AVG(salary) FROM employees WHERE AVG(salary) > 100000 GROUP BY department<\/span><\/li>\n
                      3. SELECT department, AVG(salary) FROM employees ORDER BY AVG(salary) > 100000<\/span><\/li>\n
                      4. SELECT department, AVG(salary) FROM employees LIMIT AVG(salary) > 100000<\/span><\/li>\n<\/ol>\n

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

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

                        When a condition depends on an aggregate calculation such as <\/span>AVG(salary)<\/span>, the <\/span>HAVING<\/span> clause should be used after grouping. The query groups employees by department, calculates the average salary for each group, and then retains only departments whose average exceeds the specified threshold. <\/span>WHERE<\/span> is applied before aggregation and generally cannot be used to filter the resulting aggregate value directly. <\/span>ORDER BY<\/span> sorts results, while <\/span>LIMIT<\/span> restricts the number of rows and does not perform aggregate filtering.<\/span><\/p>\n

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

                        A data engineer needs to remove all records from a table while keeping the table definition available for future inserts. Which operation is designed for this purpose?<\/b><\/p>\n

                          \n
                        1. DROP TABLE<\/span><\/li>\n
                        2. DELETE COLUMN<\/span><\/li>\n
                        3. TRUNCATE TABLE<\/span><\/li>\n
                        4. REMOVE TABLE DATA<\/span><\/li>\n<\/ol>\n

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

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

                          TRUNCATE TABLE<\/span> removes all rows from a table while retaining the table itself and its schema. This makes it useful when the table structure should remain available but the existing contents need to be cleared before a new complete load. <\/span>DROP TABLE<\/span> removes the table object itself, while <\/span>DELETE COLUMN<\/span> and <\/span>REMOVE TABLE DATA<\/span> are not appropriate standard SQL statements for this requirement. Engineers should distinguish between truncating a table and deleting selected records with a <\/span>WHERE<\/span> condition.<\/span><\/p>\n

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

                          A data engineer wants to create a new view or update an existing view using a new SQL definition without manually dropping it first. Which statement is appropriate?<\/b><\/p>\n

                            \n
                          1. CREATE OR REPLACE VIEW<\/span><\/li>\n
                          2. ALTER VIEW AS TABLE<\/span><\/li>\n
                          3. UPDATE VIEW WITH SELECT<\/span><\/li>\n
                          4. REBUILD VIEW<\/span><\/li>\n<\/ol>\n

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

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

                            CREATE OR REPLACE VIEW<\/span> allows an engineer to create a view when it does not exist or replace its existing definition with a new query. This is useful in deployment workflows where view definitions are maintained as code and updated repeatedly. It avoids requiring a separate drop operation before recreating the view. The other choices are not standard SQL patterns for replacing a view definition. Engineers should still verify dependencies and permissions when changing a view used by downstream users or applications.<\/span><\/p>\n

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

                            A pipeline receives multiple possible values for a customer’s email address. The engineer wants to use the first available non-NULL value in a defined order. Which expression should be used?<\/b><\/p>\n

                              \n
                            1. NULLIF(primary_email, secondary_email)<\/span><\/li>\n
                            2. CASE DISTINCT(primary_email, secondary_email)<\/span><\/li>\n
                            3. COALESCE(primary_email, secondary_email, backup_email)<\/span><\/li>\n
                            4. CONCAT(primary_email, secondary_email, backup_email)<\/span><\/li>\n<\/ol>\n

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

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

                              COALESCE()<\/span> is designed to return the first non-NULL expression from a list of candidates. In this scenario, it can check the primary email first, then the secondary email, and finally a backup address. This provides predictable fallback behavior without requiring multiple nested conditions. <\/span>NULLIF()<\/span> compares two expressions and may return NULL when they are equal, while <\/span>CONCAT()<\/span> combines values rather than selecting the first available one. Therefore, <\/span>COALESCE()<\/span> is the most direct solution for ordered NULL fallback handling.<\/span><\/p>\n

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

                              A data engineer needs to replace the contents of a target table with the complete results of a new SELECT query. Which approach is appropriate when the entire target dataset should be regenerated?<\/b><\/p>\n

                                \n
                              1. CREATE OR REPLACE TABLE target AS SELECT …<\/span><\/li>\n
                              2. SELECT OR REPLACE FROM target<\/span><\/li>\n
                              3. INSERT ONLY target SELECT …<\/span><\/li>\n
                              4. UPDATE TABLE target USING SELECT …<\/span><\/li>\n<\/ol>\n

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

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

                                CREATE OR REPLACE TABLE … AS SELECT<\/span> can be used when the intended result is a complete replacement of a table with the output of a new query, subject to the supported table type and operation. This differs from <\/span>INSERT INTO<\/span>, which adds rows to existing data. A full replacement approach is useful for datasets that are regenerated from a complete source snapshot. Engineers should use it carefully because existing table contents and certain metadata may be replaced depending on the operation.<\/span><\/p>\n

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

                                A data engineer wants to identify the number of records associated with each status value, such as <\/b>active<\/b>, <\/b>inactive<\/b>, and <\/b>pending<\/b>. Which SQL pattern should be used?<\/b><\/p>\n

                                  \n
                                1. SELECT status, COUNT(*) FROM customers<\/span><\/li>\n
                                2. SELECT status, COUNT(*) FROM customers ORDER BY status<\/span><\/li>\n
                                3. SELECT status, COUNT(*) FROM customers GROUP BY status<\/span><\/li>\n
                                4. SELECT status, COUNT(*) FROM customers LIMIT status<\/span><\/li>\n<\/ol>\n

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

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

                                  GROUP BY<\/span> organizes records into groups based on one or more columns, allowing aggregate functions such as <\/span>COUNT(*)<\/span> to calculate a value for each group. In this case, grouping by <\/span>status<\/span> produces one result row for each status and counts the records associated with it. <\/span>ORDER BY<\/span> can sort those results afterward but does not create the groups. <\/span>LIMIT<\/span> restricts returned rows. Therefore, <\/span>GROUP BY status<\/span> combined with <\/span>COUNT(*)<\/span> is the correct pattern for this requirement.<\/span><\/p>\n

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

                                  A data engineer wants to preserve only the rows that have a matching key in both datasets when joining customers with their transactions. Which join type should be used?<\/b><\/p>\n

                                    \n
                                  1. INNER JOIN<\/span><\/li>\n
                                  2. LEFT JOIN<\/span><\/li>\n
                                  3. FULL OUTER JOIN<\/span><\/li>\n
                                  4. CROSS JOIN<\/span><\/li>\n<\/ol>\n

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

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

                                    An <\/span>INNER JOIN<\/span> returns rows where the join condition matches in both participating datasets. When combining customers with transactions, this means only customers having matching transaction records are included, assuming the customer key is used for the join. A <\/span>LEFT JOIN<\/span> would retain all rows from the left dataset even when no transaction exists. A <\/span>FULL OUTER JOIN<\/span> includes unmatched rows from both sides, while a <\/span>CROSS JOIN<\/span> produces combinations without requiring matching keys. Thus, <\/span>INNER JOIN<\/span> directly matches the stated requirement.<\/span><\/p>\n

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

                                    A data engineer needs to keep every customer in the customer table even when some customers have no corresponding transaction records. Which join should be used when customers are on the left side?<\/b><\/p>\n

                                      \n
                                    1. INNER JOIN<\/span><\/li>\n
                                    2. LEFT JOIN<\/span><\/li>\n
                                    3. CROSS JOIN<\/span><\/li>\n
                                    4. RIGHT SEMI JOIN<\/span><\/li>\n<\/ol>\n

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

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

                                      A <\/span>LEFT JOIN<\/span> preserves every row from the left table and adds matching information from the right table when a match exists. If a customer has no transaction record, the customer can still appear in the result, with NULL values for the transaction columns. An <\/span>INNER JOIN<\/span> would exclude unmatched customers. A <\/span>CROSS JOIN<\/span> creates combinations between tables, while a right semi join does not provide the requested output structure. Therefore, a left join is suitable for retaining the complete customer population.<\/span><\/p>\n

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

                                      A data engineer wants to determine whether a query can benefit from a specific SQL execution strategy before running a large workload. Which Spark SQL feature can help inspect the planned execution?<\/b><\/p>\n

                                        \n
                                      1. DESCRIBE HISTORY<\/span><\/li>\n
                                      2. SHOW TBLPROPERTIES<\/span><\/li>\n
                                      3. EXPLAIN<\/span><\/li>\n
                                      4. VACUUM<\/span><\/li>\n<\/ol>\n

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

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

                                        The <\/span>EXPLAIN<\/span> command displays the execution plan for a query, helping engineers understand how Spark intends to perform operations such as scans, filters, joins, and aggregations. Reviewing the plan can reveal potentially expensive operations or help confirm whether expected query strategies are being applied. <\/span>DESCRIBE HISTORY<\/span> provides Delta transaction history, <\/span>SHOW TBLPROPERTIES<\/span> displays table properties, and <\/span>VACUUM<\/span> performs maintenance on eligible old files. Therefore, <\/span>EXPLAIN<\/span> is the appropriate feature for examining query execution planning.<\/span><\/p>\n

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

                                        A data engineering team wants to ensure that a complete SQL transformation can be reproduced consistently across development, testing, and production environments. Which practice best supports this requirement?<\/b><\/p>\n

                                          \n
                                        1. Store environment-specific values directly throughout the SQL logic<\/span><\/li>\n
                                        2. Manually modify the query before every deployment<\/span><\/li>\n
                                        3. Keep separate undocumented copies of the same transformation<\/span><\/li>\n
                                        4. Keep transformation logic consistent while parameterizing environment-specific configuration<\/span><\/li>\n<\/ol>\n

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

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

                                          Separating transformation logic from environment-specific configuration makes pipelines easier to reproduce and maintain across development, testing, and production. Values such as catalog names, schemas, paths, or other deployment-specific settings can be parameterized while the core transformation remains consistent. Manually editing SQL before each deployment introduces avoidable errors and makes changes difficult to track. Separate undocumented copies can also drift over time. Parameterized configuration supports repeatable deployments while keeping the business transformation logic centralized and easier to manage.<\/span><\/p>\n

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

                                          View Full Databricks Certified Data Engineer Associate Exam Dumps and Practice Test Dumps. Question 381 A data engineer wants to inspect all configuration properties of a Delta table, including properties not shown by the basic table description. Which command is most appropriate? DESCRIBE TABLE EXTENDED SHOW DATABASES SHOW FUNCTIONS DESCRIBE HISTORY Correct Answer: 1 Explanation […]<\/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\/16789"}],"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=16789"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/16789\/revisions"}],"predecessor-version":[{"id":16790,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/16789\/revisions\/16790"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=16789"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=16789"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=16789"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}