DP-900 Considerations for working practice questions
7-day money-back guarantee — full refund within 7 days of purchase if you've completed under 20% of the questions. See pricing →
Certifications Tools Flashcards Career Paths Exam Guides Blog Pricing For Teams About
Try 20 questions free →

DP-900 Describe considerations for working with non-relational data on Azure: 216 practice questions

DP-900 216 questions 12 shown free

12 of the 216 Describe considerations for working with non-relational data on Azure questions in the Certsqill DP-900 bank, shown in full below. Each one carries an explanation for every option, not just the correct one — the wrong answers are where the marks go.

Preparing for DP-900? Take the free 5-min readiness check →

1. Cosmos DB for NoSQL API: Which choice meets both requirements?

Hard
A research team stores laboratory observations as JSON documents with varying optional properties. Within the Azure Cosmos DB API family, the team wants a supported existing interface that accepts SQL-like queries over those documents. Which choice meets both requirements?
  1. Cosmos DB for NoSQL API ✓
    The NoSQL API stores JSON documents and supports its SQL-like query language through a supported Cosmos interface.
  2. Cosmos DB Table API
    The Table API provides key-value entity compatibility, rather than the requested JSON document query interface.
  3. Cosmos DB Cassandra API
    The Cassandra API uses CQL with a wide-column model, not the requested JSON document interface and SQL-like document queries.
  4. Cosmos DB MongoDB API
    The MongoDB API supports MongoDB-compatible clients and document workloads, but not the specified Cosmos SQL-like interface.
The trap
Table entities are not the requested document-query model. MongoDB compatibility is different from the requested SQL-like interface. CQL and wide columns represent a different Cosmos data model.

Cosmos DB for NoSQL provides JSON documents and SQL-like queries within the Cosmos API family.

2. Azure Blob Storage: Which Azure service is appropriate?

Medium
An online training provider stores course thumbnail images and downloadable video files. The application needs object storage accessed through containers, not a shared network file system or relational tables. Which Azure service is appropriate?
  1. Azure SQL Database
    SQL Database provides relational tables and queries, not the requested object-storage pattern for media files.
  2. Azure Table Storage
    Table Storage stores schemaless key-attribute entities, not large image and video objects as containers.
  3. Azure Files
    Azure Files provides managed file shares, which are intended for shared filesystem access rather than containerized objects.
  4. Azure Blob Storage ✓
    Blob Storage stores image and video objects in containers, making it appropriate for this object-based workload.
The trap
Entities are unsuitable as the primary image and video store. File shares use filesystem protocols instead of object containers. Relational tables are not the stated object-storage requirement.

Blob Storage is designed for image and video objects held in containers.

3. A NoSQL document service can provide SQL-like queries: Which interpretation is correct?

Easy
Your logistics company wants a distributed document service. Developers notice that the service accepts SQL-like queries, but the documents do not require relational tables, foreign keys, or a SQL Server engine. Which interpretation is correct?
  1. A NoSQL document service can provide SQL-like queries without becoming a relational SQL Server engine. ✓
    A NoSQL document service may query JSON documents with SQL-like syntax while retaining a non-relational data model.
  2. It is necessarily Azure SQL Database because documents can contain JSON.
    Azure SQL Database can store JSON, but JSON support does not identify the service or make every document service relational.
  3. It must be a relational database because SQL-like queries require tables.
    SQL-like query syntax can operate over non-relational documents, so syntax alone does not establish a relational engine.
  4. It must be Azure Table Storage because the data is non-relational.
    Table Storage uses key-attribute entities, while a document service may use a different non-relational model and interface.
The trap
Query syntax does not determine the underlying data model. Non-relational systems include multiple distinct data models. JSON capability exists in both relational and non-relational contexts.

SQL-like syntax describes an interface, not proof that the underlying service is relational.

4. Azure Blob Storage: Which Azure service family is the most suitable starting point?

Easy
A software company collects application logs and large analytics files. Analysts need scalable object storage and may later use data-lake capabilities. Which Azure service family is the most suitable starting point?
  1. Azure Blob Storage ✓
    Blob Storage is suitable for scalable storage of logs, analytics files, and other unstructured data objects.
  2. Azure Table Storage
    Table Storage stores key-attribute entities, not general-purpose analytics files and log objects.
  3. Azure SQL Database
    SQL Database manages relational data, whereas the requirement centers on analytics files and object storage.
  4. Azure Files
    Azure Files supplies managed file shares, which are better when applications require shared filesystem protocols.
The trap
Entity storage does not replace object storage for large files. Relational querying is not the primary stated requirement. Shared file access is different from analytics object storage.

Blob Storage supports analytics files, logs, and data-lake-oriented object storage.

5. Cosmos DB API for MongoDB: Which choice is most appropriate?

Medium
You have a college admissions application built with a MongoDB-compatible client. The team wants a managed Azure document service and prefers to preserve that supported client interface rather than rewrite queries immediately. Which choice is most appropriate?
  1. Cosmos DB Cassandra API
    The Cassandra API is designed for CQL and wide-column workloads, not MongoDB-compatible application clients.
  2. Cosmos DB for NoSQL API
    The NoSQL API supports JSON documents and SQL-like queries, but it is not the requested MongoDB-compatible client interface.
  3. Cosmos DB Table API
    The Table API supports key-value entity compatibility, which does not meet the application's MongoDB client requirement.
  4. Cosmos DB API for MongoDB ✓
    The MongoDB API supports MongoDB-compatible clients within supported features while providing a managed document service.
The trap
Table compatibility does not provide MongoDB client behavior. A document model alone does not preserve MongoDB client compatibility. CQL clients target a different data model and interface.

The Cosmos DB MongoDB API preserves the required supported MongoDB-compatible client interface.

6. Azure Files: Which Azure service should the team choose?

Easy
A media studio needs several Windows workstations to open and edit shared project folders using standard SMB paths. The files should appear as a shared filesystem rather than objects accessed through containers. Which Azure service should the team choose?
  1. Azure SQL Database
    SQL Database stores relational rows and columns, rather than exposing shared project folders through SMB.
  2. Azure Files ✓
    Azure Files provides managed file shares accessible through supported SMB configurations for shared filesystem workloads.
  3. Azure Blob Storage
    Blob Storage provides object containers and blob access, not the requested SMB-based shared folder experience.
  4. Azure Table Storage
    Table Storage stores key-attribute entities and does not expose shared folders or SMB file paths.
The trap
Entity storage has no shared filesystem interface. Object containers do not provide the stated shared filesystem protocol. Relational tables cannot substitute for SMB file shares.

Azure Files supplies managed shares for supported SMB-based shared-folder access.

7. Cosmos DB Cassandra API: Which Azure Cosmos DB API should the team select?

Medium
A retailer's product catalog must support Cassandra-compatible applications and a wide-column data model. Which Azure Cosmos DB API should the team select?
  1. Cosmos DB for NoSQL API
    The NoSQL API centers on JSON documents and its SQL-like query interface, not Cassandra CQL modeling.
  2. Cosmos DB MongoDB API
    The MongoDB API supports MongoDB-compatible document workloads rather than Cassandra-compatible wide-column applications.
  3. Cosmos DB Cassandra API ✓
    The Cassandra API supports Cassandra-compatible workloads using CQL and a wide-column data model.
  4. Cosmos DB Table API
    The Table API supports key-value entity compatibility, not the required Cassandra CQL and wide-column model.
The trap
MongoDB documents do not provide the Cassandra interface. Document querying is a different model from Cassandra wide columns. Table entities use a different compatibility model and protocol.

The Cosmos DB Cassandra API matches CQL applications and wide-column modeling.

8. Azure Files: Which service or component is directly responsible for providing the required access pattern?

Medium
A clinic wants staff computers to open shared patient-document folders through standard SMB paths. The team is considering Blob Storage because it stores files. Which service or component is directly responsible for providing the required access pattern?
  1. Blob containers
    Blob containers organize objects, but they do not provide the requested SMB shared-folder interface.
  2. Azure Files ✓
    Azure Files provides managed shares through supported SMB configurations, matching standard shared-folder access.
  3. Azure Table entities
    Table entities store key-attribute records and cannot expose patient-document folders through SMB paths.
  4. A relational database schema
    A relational schema organizes rows and columns, but it does not provide SMB file-share access.
The trap
Database structure does not expose standard file paths. Container organization does not create filesystem protocol access. Entity records are not shared files or directories.

Azure Files, unlike Blob containers, provides supported SMB access to managed shares.

9. Use the Gremlin API for graph vertices: Which Cosmos DB API concept best matches this requirement?

Easy
You have an energy provider mapping substations, connected cables, and neighboring substations. The team must find paths between substations. Exhibit: Data model: vertex = substation; edge = cable; operation = traverse connected vertices. Which Cosmos DB API concept best matches this requirement?
  1. Use the Table API with PartitionKey and RowKey values.
    Table entities support key-based access, but they do not naturally represent traversable relationships between vertices.
  2. Use the Gremlin API for graph vertices, edges, and relationship traversals. ✓
    Gremlin represents entities as vertices, relationships as edges, and supports traversals across connected graph data.
  3. Use the NoSQL API with JSON documents and SQL-like queries.
    NoSQL documents can store relationship data, but graph traversal is not their defining access model.
  4. Use Blob Storage containers for cable and substation records.
    Blob Storage stores objects and files, rather than modeling connected entities and traversable relationships.
The trap
Objects and containers are not graph structures. Key-based entities do not provide graph traversal semantics. Document queries differ from traversing connected edges.

Gremlin is designed for graph vertices, edges, and traversals across connected data.

10. Table Storage uses schemaless key/attribute entities: What explains why both records can be stored without a p

Easy
A finance team stores payment records in Azure Table Storage. Two records have different descriptive attributes, but each has a PartitionKey and RowKey. What explains why both records can be stored without a predefined table schema?
  1. Table Storage uses schemaless key/attribute entities. ✓
    Azure Table Storage permits entities within a table to have varying attributes beyond their identifying keys.
  2. Table Storage requires every entity to contain identical columns.
    Unlike relational tables, Table Storage does not require identical property sets for every entity.
  3. Table Storage automatically creates foreign keys between records.
    Table Storage does not automatically create relational foreign keys between stored entities.
  4. Table Storage stores each record as an object in Blob Storage.
    Table Storage is a separate key/attribute service, not a collection of Blob Storage objects.
The trap
Storage services use different data models. Varying attributes do not imply relationship enforcement. This describes stricter relational schema behavior.

Table Storage is schemaless, allowing entities to carry different properties while retaining required keys.

11. Select Cosmos DB for Table with its Table API: Which choice best satisfies the requirement?

Medium
Your online store already uses applications written for the Azure Table Storage interface. The team wants a managed Cosmos DB option while minimizing changes to those applications. Which choice best satisfies the requirement?
  1. Select Cosmos DB Gremlin API for graph traversal.
    Gremlin is appropriate for graph vertices and edges, but it does not preserve a Table API application interface.
  2. Select Cosmos DB for Table with its Table API compatibility. ✓
    Cosmos DB for Table supports the Table API model, helping existing compatible table-oriented applications continue working.
  3. Select Cosmos DB NoSQL API for JSON document queries.
    The NoSQL API uses JSON documents and SQL-like queries, requiring a different application data model.
  4. Select Azure Blob Storage for object-based application persistence.
    Blob Storage stores objects in containers and does not provide Table API entity compatibility.
The trap
Graph compatibility does not preserve table clients. Object storage cannot substitute for table entities. Document compatibility is not Table API compatibility.

Cosmos DB for Table provides the relevant Table API compatibility for existing table-oriented applications.

12. PartitionKey groups entities into a partition: Which TWO statements correctly describe the required identifyin

Medium
A nonprofit stores volunteer entities in Azure Table Storage. Which TWO statements correctly describe the required identifying values and the service's relational behavior? Select TWO.

Select two. More than one option is correct — every correct one is ticked below.

  1. The service automatically enforces foreign-key relationships.
    Table Storage does not automatically enforce foreign keys or relational relationships between entities.
  2. PartitionKey groups entities into a partition. ✓
    PartitionKey identifies the partition placement grouping used for Table Storage entities.
  3. RowKey creates joins across separate tables.
    RowKey supports entity identification, but Table Storage does not provide automatic relational joins.
  4. RowKey identifies an entity within its partition. ✓
    RowKey distinguishes an entity within its PartitionKey grouping, together forming its table identity.
  5. Every entity must use identical descriptive properties.
    Entities can have varying non-key properties because Table Storage is schemaless.
The trap
Identification is different from joining. Uniform properties are not required. Key fields identify entities, not relational dependencies.

PartitionKey groups entities, while RowKey identifies one entity within that group; neither creates relational constraints.

204 more Describe considerations for working with non-relational data on Azure questions

The remaining 204 questions in this domain are part of the full DP-900 bank — 1080 questions, every option explained. Start with the free five-minute check and see your score per domain.

Test your DP-900 readiness — free

Other DP-900 domains

Part of the Certsqill DP-900 question bank · Describe considerations for working with non-relational data on Azure · Every answer, right and wrong, comes with its own explanation.