{"id":16519,"date":"2026-09-19T07:49:53","date_gmt":"2026-09-19T07:49:53","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=16519"},"modified":"2026-09-19T07:49:53","modified_gmt":"2026-09-19T07:49:53","slug":"microsoft-dp-420-practice-test-questions-and-exam-dumps-part19-q361-380","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/microsoft-dp-420-practice-test-questions-and-exam-dumps-part19-q361-380\/","title":{"rendered":"Microsoft DP-420 Practice Test Questions and Exam Dumps Part19 Q361-380"},"content":{"rendered":"

 <\/p>\n

View Full <\/b>Microsoft DP-420 Exam Dumps<\/b><\/a> and Practice Test Dumps.<\/b><\/p>\n


\n<\/b>Q1. An Azure Cosmos DB for NoSQL container uses <\/b>\/tenantId<\/b> as its partition key. An existing item must be moved from tenant A to tenant B. What should your application do?<\/b><\/p>\n

    \n
  1. <\/b> Patch the existing partition-key value.<\/span><\/li>\n
  2. <\/b> Replace the item and specify the new partition key.<\/span><\/li>\n
  3. <\/b> Change the container’s partition-key definition.<\/span><\/li>\n
  4. <\/b> Create a new item using the new partition key and remove the old item.<\/span><\/li>\n<\/ol>\n

    Correct Answer: 4. Create a new item using the new partition key and remove the old item.<\/b><\/p>\n

    Explanation:<\/b> The partition-key value of an existing Cosmos DB item cannot simply be changed in place. The partition key determines the item’s logical partition and therefore its placement and routing. To move an item to another partition-key value, the application typically creates a new item containing the required data under the new key and then removes the original item. The application should consider concurrency and consistency during the move. Patch and Replace can modify document content, but they cannot migrate an existing item to a different logical partition by changing its partition-key value.<\/span><\/p>\n

    Q2. A Cosmos DB container uses <\/b>\/customerId<\/b> as its partition key. Two customers both have an item with <\/b>id<\/b> equal to <\/b>“profile”<\/b>. Is this allowed?<\/b><\/p>\n

      \n
    1. <\/b> Yes, because the combination of <\/span>id<\/span> and partition-key value uniquely identifies an item.<\/span><\/li>\n
    2. <\/b> No, because <\/span>id<\/span> must be globally unique across the account.<\/span><\/li>\n
    3. <\/b> No, because all IDs must be GUIDs.<\/span><\/li>\n
    4. <\/b> Yes, but only if indexing is disabled.<\/span><\/li>\n<\/ol>\n

      Correct Answer: 1. Yes, because the combination of <\/b>id<\/b> and partition-key value uniquely identifies an item.<\/b><\/p>\n

      Explanation:<\/b> In a partitioned Cosmos DB for NoSQL container, item identity is determined by the combination of the item’s <\/span>id<\/span> and partition-key value. Therefore, two logical partitions can contain items with the same <\/span>id<\/span>, provided their partition-key values differ. Within the same logical partition, however, two items cannot share the same <\/span>id<\/span>. This distinction is important when designing identifiers for multitenant systems. IDs do not have to be GUIDs, and indexing configuration does not determine whether duplicate IDs are permitted across different logical partitions.<\/span><\/p>\n

      Q3. You are designing a synthetic partition key that combines <\/b>tenantId<\/b> and a bucket number. What is the primary purpose of the bucket value?<\/b><\/p>\n

        \n
      1. <\/b> To enable Strong consistency.<\/span><\/li>\n
      2. <\/b> To enforce unique keys.<\/span><\/li>\n
      3. <\/b> To spread a high-volume tenant across more partition-key values.<\/span><\/li>\n
      4. <\/b> To enable TTL.<\/span><\/li>\n<\/ol>\n

        Correct Answer: 3. To spread a high-volume tenant across more partition-key values.<\/b><\/p>\n

        Explanation:<\/b> A synthetic partition key can combine business attributes with an additional generated value, such as a bucket number, to increase cardinality and distribute a workload more evenly. This can be useful when a natural key such as tenant ID aligns well with queries but one or more tenants produce enough data or traffic to become hot. The application must know how to generate or locate the correct bucket when accessing data. Bucketing does not change consistency, TTL, or unique-key behavior. Its primary purpose is to improve storage and throughput distribution.<\/span><\/p>\n

        Q4. Several item operations must participate in one transaction. What must be true about those items in Azure Cosmos DB for NoSQL?<\/b><\/p>\n

          \n
        1. <\/b> They must all use the same <\/span>id<\/span>.<\/span><\/li>\n
        2. <\/b> They must belong to the same logical partition.<\/span><\/li>\n
        3. <\/b> They must all be stored in analytical store.<\/span><\/li>\n
        4. <\/b> They must use Eventual consistency.<\/span><\/li>\n<\/ol>\n

          Correct Answer: 2. They must belong to the same logical partition.<\/b><\/p>\n

          Explanation:<\/b> Transactional operations in Azure Cosmos DB are scoped to a logical partition. Features such as Transactional Batch and server-side stored procedures can perform atomic work across multiple items only when those items share the same partition-key value. This makes transaction requirements an important consideration when choosing a partition key. Items do not need the same ID, and analytical store or consistency level does not expand the transactional boundary. If business operations require atomic updates to several entities, modeling those entities into the same logical partition can simplify the implementation.<\/span><\/p>\n

          Q5. A container has TTL enabled with a default value of 600 seconds. One specific item should use a different expiration period of 3,600 seconds. What should you do?<\/b><\/p>\n

            \n
          1. <\/b> Create a separate database account.<\/span><\/li>\n
          2. <\/b> Change the consistency level for that item.<\/span><\/li>\n
          3. <\/b> Add the item to a composite index.<\/span><\/li>\n
          4. <\/b> Set an item-level TTL value of 3,600 seconds.<\/span><\/li>\n<\/ol>\n

            Correct Answer: 4. Set an item-level TTL value of 3,600 seconds.<\/b><\/p>\n

            Explanation:<\/b> When TTL is enabled for a container, individual items can override the container’s default expiration period by supplying their own TTL value. This is useful when most documents share a standard retention policy but particular records require a longer or shorter lifetime. Creating separate infrastructure solely for the different expiration period would be unnecessary. Consistency and indexing do not control document expiration. Item-level TTL lets lifecycle behavior remain flexible while still benefiting from automatic Cosmos DB cleanup rather than requiring custom deletion jobs.<\/span><\/p>\n

            Q6. A query should return only a scalar product name instead of complete JSON objects. Which Cosmos DB SQL form should you consider?<\/b><\/p>\n

              \n
            1. <\/b> SELECT *<\/span><\/li>\n
            2. <\/b> SELECT VALUE<\/span><\/li>\n
            3. <\/b> SELECT JOIN<\/span><\/li>\n
            4. <\/b> SELECT TTL<\/span><\/li>\n<\/ol>\n

              Correct Answer: 2. <\/b>SELECT VALUE<\/b><\/p>\n

              Explanation:<\/b> SELECT VALUE<\/span> can project a scalar or other value directly rather than wrapping the result in an object property. For example, a query can return product names as plain values when the application does not require complete JSON objects. This can make query responses cleaner and reduce unnecessary structure in the returned payload. <\/span>SELECT *<\/span> returns complete items or projected objects depending on the query form. JOIN is used to work with nested arrays, and TTL is not a SQL projection keyword for this purpose.<\/span><\/p>\n

              Q7. You need a query that returns the total sales amount for each category. Which SQL feature should you use?<\/b><\/p>\n

                \n
              1. <\/b> GROUP BY<\/span> with an aggregate function.<\/span><\/li>\n
              2. <\/b> A continuation token only.<\/span><\/li>\n
              3. <\/b> TTL.<\/span><\/li>\n
              4. <\/b> A Patch operation.<\/span><\/li>\n<\/ol>\n

                Correct Answer: 1. <\/b>GROUP BY<\/b> with an aggregate function.<\/b><\/p>\n

                Explanation:<\/b> GROUP BY<\/span> can group matching documents according to one or more properties, while aggregate functions such as <\/span>SUM<\/span>, <\/span>COUNT<\/span>, or <\/span>AVG<\/span> calculate values for each group. This is appropriate when a query needs results such as total sales by category. Continuation tokens control pagination rather than aggregation, while TTL and Patch handle lifecycle and mutation concerns. Aggregation queries can still consume significant request units when they scan many partitions, so partition-key alignment and indexing should be considered when these queries are frequent or operate over large datasets.<\/span><\/p>\n

                Q8. Your application stores locations as GeoJSON points and needs to find records within a given polygon. Which function and index category should you use?<\/b><\/p>\n

                  \n
                1. <\/b> VectorDistance<\/span> with a vector index.<\/span><\/li>\n
                2. <\/b> FullTextContains<\/span> with a full-text index.<\/span><\/li>\n
                3. <\/b> A spatial function such as <\/span>ST_WITHIN<\/span> with spatial indexing.<\/span><\/li>\n
                4. <\/b> ARRAY_CONTAINS<\/span> with a composite index.<\/span><\/li>\n<\/ol>\n

                  Correct Answer: 3. A spatial function such as <\/b>ST_WITHIN<\/b> with spatial indexing.<\/b><\/p>\n

                  Explanation:<\/b> Cosmos DB supports geospatial data and spatial SQL functions for location-based queries. A function such as <\/span>ST_WITHIN<\/span> can determine whether a GeoJSON point or shape lies within another geometry, while spatial indexing improves execution efficiency. Vector search addresses semantic similarity, full-text search handles language-oriented text retrieval, and array functions operate on JSON arrays. Applications that use geographic queries should correctly represent their GeoJSON values and configure the corresponding spatial paths in the indexing policy.<\/span><\/p>\n

                  Q9. You are building native text search and want query results ranked according to how relevant each document is to the user’s search terms. Which capability is relevant?<\/b><\/p>\n

                    \n
                  1. <\/b> TTL scoring.<\/span><\/li>\n
                  2. <\/b> Unique-key ranking.<\/span><\/li>\n
                  3. <\/b> Session-token ranking.<\/span><\/li>\n
                  4. <\/b> Full-text scoring.<\/span><\/li>\n<\/ol>\n

                    Correct Answer: 4. Full-text scoring.<\/b><\/p>\n

                    Explanation:<\/b> Cosmos DB’s native full-text capabilities include relevance scoring that can be used to rank documents according to how well they match a text query. Full-text search uses specialized text processing such as tokenization, stemming, and stop-word handling when configured with the appropriate full-text policy and index. This makes it better suited to relevance-oriented keyword search than ordinary scalar string comparisons. TTL, unique keys, and session tokens solve unrelated lifecycle, integrity, and consistency concerns.<\/span><\/p>\n

                    Q10. You are building semantic search over text embeddings stored in Cosmos DB. Which function is used to compare a query vector with stored vectors?<\/b><\/p>\n

                      \n
                    1. <\/b> VectorDistance<\/span><\/li>\n
                    2. <\/b> ARRAY_LENGTH<\/span><\/li>\n
                    3. <\/b> DateTimeDiff<\/span><\/li>\n
                    4. <\/b> IS_NULL<\/span><\/li>\n<\/ol>\n

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

                      Explanation:<\/b> VectorDistance<\/span> calculates similarity or distance between a supplied query vector and embeddings stored in Cosmos DB. Combined with a configured vector embedding policy and vector index, it supports semantic retrieval, recommendations, and retrieval-augmented generation. The closest vectors represent items that are most similar according to the configured distance metric. Array, date, and type-checking functions serve entirely different query needs. Native Cosmos DB vector search allows applications to keep operational data and embeddings together in the same database architecture.<\/span><\/p>\n

                      Q11. You use latest-version change feed mode. A document is deleted. What should a consumer expect from the normal change feed?<\/b><\/p>\n

                        \n
                      1. <\/b> A full delete event containing the old document.<\/span><\/li>\n
                      2. <\/b> The delete is not captured as a normal change event.<\/span><\/li>\n
                      3. <\/b> Every previous version is returned.<\/span><\/li>\n
                      4. <\/b> The feed automatically restores the document.<\/span><\/li>\n<\/ol>\n

                        Correct Answer: 2. The delete is not captured as a normal change event.<\/b><\/p>\n

                        Explanation:<\/b> Latest-version change feed mode records creates and updates, but it does not capture deletes as change events. Once an item is deleted, it is removed from the latest-version feed. If delete detection is required while using this mode, applications can use a soft-delete pattern, such as setting a deleted flag and optionally applying TTL afterward. All versions and deletes mode is the alternative when complete delete events and intermediate versions are required.<\/span><\/p>\n

                        Q12. You use latest-version change feed mode but still need downstream processors to detect deletions. Which pattern can you implement?<\/b><\/p>\n

                          \n
                        1. <\/b> Disable change feed.<\/span><\/li>\n
                        2. <\/b> Remove the partition key.<\/span><\/li>\n
                        3. <\/b> Mark the item as deleted, let the change feed capture the update, and expire it later with TTL.<\/span><\/li>\n
                        4. <\/b> Enable integrated cache.<\/span><\/li>\n<\/ol>\n

                          Correct Answer: 3. Mark the item as deleted, let the change feed capture the update, and expire it later with TTL.<\/b><\/p>\n

                          Explanation:<\/b> A common delete-detection pattern in latest-version change feed mode is soft deletion. Instead of immediately deleting the item, the application updates it with a property such as <\/span>deleted: true<\/span>. That update appears in the change feed and can be processed downstream. TTL can then remove the item automatically after enough time has passed for change consumers to see the marker. This pattern is useful because latest-version mode does not directly record delete events.<\/span><\/p>\n

                          Q13. You need the change feed to include every update version and deletion for audit processing. Which mode should you configure?<\/b><\/p>\n

                            \n
                          1. <\/b> All versions and deletes mode.<\/span><\/li>\n
                          2. <\/b> Latest version mode.<\/span><\/li>\n
                          3. <\/b> Integrated cache mode.<\/span><\/li>\n
                          4. <\/b> Analytical-store mode.<\/span><\/li>\n<\/ol>\n

                            Correct Answer: 1. All versions and deletes mode.<\/b><\/p>\n

                            Explanation:<\/b> All versions and deletes mode records creates, intermediate updates, and deletes, preserving a much richer history than latest-version mode. It is useful for audit, synchronization, and scenarios where each individual change matters. This mode requires continuous backup and only exposes changes that fall within the configured continuous-backup retention window. Latest-version mode provides only the newest version of created or updated items and does not capture normal deletes.<\/span><\/p>\n

                            Q14. A change feed pull-model consumer in all versions and deletes mode stores a continuation token. How long can that token remain useful?<\/b><\/p>\n

                              \n
                            1. <\/b> Forever, even after the container is deleted.<\/span><\/li>\n
                            2. <\/b> It is valid only while the referenced changes remain within the continuous-backup retention window.<\/span><\/li>\n
                            3. <\/b> Exactly one hour.<\/span><\/li>\n
                            4. <\/b> Only until the next item is inserted.<\/span><\/li>\n<\/ol>\n

                              Correct Answer: 2. It is valid only while the referenced changes remain within the continuous-backup retention window.<\/b><\/p>\n

                              Explanation:<\/b> In all versions and deletes mode, change history is tied to the continuous-backup retention window. A pull-model continuation token can resume processing only while the corresponding changes remain available within that retention period. This differs from latest-version mode, where continuation tokens remain usable for the lifetime of the container. Applications using all versions and deletes mode should therefore avoid leaving processors inactive beyond the relevant retention window if complete processing history is required.<\/span><\/p>\n

                              Q15. You need serverless code to process all versions and deletes change feed events. Which design requirement should you verify?<\/b><\/p>\n

                                \n
                              1. <\/b> The correct Azure Functions Cosmos DB extension and supported programming model are being used.<\/span><\/li>\n
                              2. <\/b> Integrated cache is enabled.<\/span><\/li>\n
                              3. <\/b> Every document has the same ID.<\/span><\/li>\n
                              4. <\/b> The account uses Eventual consistency.<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 1. The correct Azure Functions Cosmos DB extension and supported programming model are being used.<\/b><\/p>\n

                                Explanation:<\/b> Azure Functions can consume Cosmos DB change feed events, including all versions and deletes mode when the appropriate supported extension and programming model are used. The account must also have continuous backup enabled and the all versions and deletes change feed feature turned on. Integrated cache, IDs, and Eventual consistency are not the enabling requirements. When using evolving platform features, developers should verify SDK or Functions extension compatibility as part of the solution design.<\/span><\/p>\n

                                Q16. You need a change feed pull-model consumer to process only a specific range of partition-key values. What should you provide?<\/b><\/p>\n

                                  \n
                                1. <\/b> A TTL policy.<\/span><\/li>\n
                                2. <\/b> A unique key.<\/span><\/li>\n
                                3. <\/b> A <\/span>FeedRange<\/span>.<\/span><\/li>\n
                                4. <\/b> A vector policy.<\/span><\/li>\n<\/ol>\n

                                  Correct Answer: 3. A <\/b>FeedRange<\/b>.<\/b><\/p>\n

                                  Explanation:<\/b> The change feed pull model supports reading changes from a specific feed range. A <\/span>FeedRange<\/span> represents a range of partition-key values and allows an application to divide change processing explicitly across workers or custom processing units. This gives developers more control than the higher-level change feed processor, which manages leases and balancing automatically. TTL, unique keys, and vector policies serve unrelated lifecycle, integrity, and search requirements. The pull model is most useful when custom scheduling and ownership logic justify the added complexity.<\/span><\/p>\n

                                  Q17. Your account uses multiple read regions and one write region. You want a planned maintenance operation to move the write region intentionally. What should you perform?<\/b><\/p>\n

                                    \n
                                  1. <\/b> Integrated-cache refresh.<\/span><\/li>\n
                                  2. <\/b> TTL reset.<\/span><\/li>\n
                                  3. <\/b> Index transformation.<\/span><\/li>\n
                                  4. <\/b> Manual failover.<\/span><\/li>\n<\/ol>\n

                                    Correct Answer: 4. Manual failover.<\/b><\/p>\n

                                    Explanation:<\/b> Manual failover allows administrators to intentionally move the write role to another configured region in an account that uses a single write region. This is useful for planned maintenance, operational testing, and disaster-recovery exercises. Automatic failover serves a different purpose by promoting another region when a write-region outage occurs according to configured priorities. Cache, TTL, and indexing do not change regional write ownership. Failover procedures should be tested together with application preferred-region settings and operational runbooks.<\/span><\/p>\n

                                    Q18. You need to compare Cosmos DB server-side processing latency with total application-observed latency. Why is this useful?<\/b><\/p>\n

                                      \n
                                    1. <\/b> It helps determine whether delays are inside Cosmos DB or in client\/network processing.<\/span><\/li>\n
                                    2. <\/b> It changes the partition key automatically.<\/span><\/li>\n
                                    3. <\/b> It enables point-in-time restore.<\/span><\/li>\n
                                    4. <\/b> It disables 429 responses.<\/span><\/li>\n<\/ol>\n

                                      Correct Answer: 1. It helps determine whether delays are inside Cosmos DB or in client\/network processing.<\/b><\/p>\n

                                      Explanation:<\/b> Server-side latency measures the time Cosmos DB spends processing a request within the service. End-to-end application latency also includes network transit, client connection handling, retries, thread scheduling, serialization, and application processing. Comparing the two helps identify where the delay is actually occurring. If server latency is low but application latency is high, client or network issues should be investigated using SDK diagnostics and application telemetry. This comparison does not alter partitioning, backup, or throttling behavior.<\/span><\/p>\n

                                      Q19. You want application and Cosmos DB resource logs to be analyzed together using Kusto Query Language. What should you configure?<\/b><\/p>\n

                                        \n
                                      1. <\/b> TTL.<\/span><\/li>\n
                                      2. <\/b> Azure Monitor diagnostic settings that send Cosmos DB logs to Log Analytics.<\/span><\/li>\n
                                      3. <\/b> A stored procedure.<\/span><\/li>\n
                                      4. <\/b> Integrated cache.<\/span><\/li>\n<\/ol>\n

                                        Correct Answer: 2. Azure Monitor diagnostic settings that send Cosmos DB logs to Log Analytics.<\/b><\/p>\n

                                        Explanation:<\/b> Azure Monitor diagnostic settings can route Cosmos DB resource logs to a Log Analytics workspace. Once centralized, Kusto Query Language can be used to analyze database activity alongside application, network, and other Azure telemetry. This is useful for performance troubleshooting, auditing, security analysis, and incident investigation. TTL, stored procedures, and cache do not provide centralized operational logging. Correlation identifiers in application telemetry can further improve the ability to match Cosmos DB requests with user-facing operations.<\/span><\/p>\n

                                        Q20. You need an alert when Cosmos DB server-side latency stays above the application’s service objective for five minutes. Which solution should you implement?<\/b><\/p>\n

                                          \n
                                        1. <\/b> A unique key policy.<\/span><\/li>\n
                                        2. <\/b> TTL.<\/span><\/li>\n
                                        3. <\/b> An Azure Monitor alert rule using the latency metric and an action group.<\/span><\/li>\n
                                        4. <\/b> A query continuation token.<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 3. An Azure Monitor alert rule using the latency metric and an action group.<\/b><\/p>\n

                                          Explanation:<\/b> Azure Monitor alerts can evaluate Cosmos DB service metrics against defined thresholds and time windows. A latency alert can detect when server-side processing remains above the application’s service objective rather than reacting to a single short-lived spike. An action group can notify operations staff or trigger automated workflows. Unique keys, TTL, and continuation tokens do not provide operational alerting. Effective monitoring should use thresholds that are meaningful for the application’s normal workload and should complement alerts for throttling, failures, availability, and partition-level resource pressure.<\/span><\/p>\n

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

                                            View Full Microsoft DP-420 Exam Dumps and Practice Test Dumps. Q1. An Azure Cosmos DB for NoSQL container uses \/tenantId as its partition key. An existing item must be moved from tenant A to tenant B. What should your application do? Patch the existing partition-key value. Replace the item and specify the new partition […]<\/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\/16519"}],"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=16519"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/16519\/revisions"}],"predecessor-version":[{"id":16562,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/16519\/revisions\/16562"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=16519"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=16519"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=16519"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}