CCNA Describe core data concepts Questions

Isolation is the ACID property that separates the effects of concurrent transactions so that one transaction cannot see the intermediate, uncommitted state of another. Without isolation, a POS system could read inventory levels that another sale is in the middle of updating, leading to overselling or duplicate charges. Isolation ensures that the concurrent execution produces the same result as some serial order of the transactions, thereby preventing dirty reads, non-repeatable reads, and phantom reads. This directly addresses the retail scenario described.

Customer contact information is structured because it resides in a table with a fixed, predefined schema: each column (name, phone, email) has a strict data type and every row must conform to that schema, making it directly queryable via SQL. Chat transcripts, by contrast, are unstructured because the conversation is free-flowing natural language with no fixed format, row/column structure, or guaranteed fields; the text is stored as a whole and cannot be reliably queried by column value without additional processing like text mining or NLP.

Power BI connects directly to Azure SQL Database and provides interactive dashboards with drill-down, satisfying the marketing team's visualisation requirement. Unlike static reporting tools, its semantic model supports hierarchical navigation, letting users explore purchase history across customer, product and time dimensions without writing queries.

This query filters storm events to those on or after 2024-01-01, groups the remaining rows by State using `summarize`, and computes the sum of DamageProperty for each state. The subsequent `top 5 by DamageProperty desc` operator sorts these state-level sums in descending order and returns the first five rows, which are exactly the five states with the highest total property damage. The result is a ranked list of the top 5 states by total damage.

The OrderID, CustomerName, and OrderDate columns have fixed data types and enforce a rigid schema, exactly fitting the structured category. In contrast, the JSON column stores order details that can differ per customer order, such as optional fields or nested line items, which is typical of semi-structured data. A single table can therefore mix both categories, and that is precisely what this design does.

Correct. Audio and free-text are both unstructured; the structured table is most structured.

This is exactly what the query does: summarize by EventType groups the Texas storm records by event category, sum(PropertyDamage) totals the damage within each group, and the top operator (or order by + take) selects the five highest groups. Each output row pairs an EventType with its aggregated damage, which is the standard KQL pattern for a ranked breakdown. The result therefore identifies which event types had the most total property damage in Texas.

Atomicity is the correct property here because it enforces the all-or-nothing execution of a transaction. In this funds transfer, the debit step was written, but the corresponding credit never completed before the crash. Atomicity requires the entire transaction to be treated as a single, indivisible unit, so the partial debit must be rolled back and the account restored to its original state. Without atomicity, a system failure could leave a half-applied transaction, corrupting financial records.

Microsoft Purview is a unified data governance and cataloging service that automatically scans Azure, on-premises, and multi-cloud sources, building a data map of technical and business metadata. It provides a searchable catalog, sensitive data classification, glossary, and end-to-end lineage across various data processes. This makes Purview the correct choice for governing a data lake, ensuring data is discoverable, understandable, and compliant.

Azure Synapse Serverless SQL pool is a serverless query service that lets you run T-SQL queries directly against files stored in Azure Blob Storage or Azure Data Lake Storage Gen2. Using OPENROWSET or external tables, you can query CSV, JSON, or Parquet files without loading them into a database first. It scales on demand and charges by the amount of data processed, making it the correct choice for running SQL directly on stored data.

This option is correct because a table with defined columns and specified data types is the hallmark of structured data, which conforms to a fixed schema typical of relational database management systems. Each customer record will have the same set of attributes, and constraints enforce consistency, allowing efficient querying with SQL. Since the company stores customer information in such a normalized, column-based format, the data is structured.

Employee records stored in a relational database have a fixed, predefined schema with columns, data types, and constraints, making them structured data. Employee handbooks are PDF documents containing free-form prose and formatting without any uniform data model, so they are unstructured. Customer feedback in XML uses custom tags and nesting such as <response> and <sentiment> to describe the content, giving it a self-describing yet flexible schema that qualifies as semi-structured.

Power BI is a SaaS-based business analytics service specifically designed for self-service analytics. It provides a low-code environment with drag-and-drop visuals, natural language Q&A, and direct connectivity to a wide range of data sources. Power BI supports self-service data preparation via Power Query and enables governed sharing through workspaces, apps, and row-level security, making it the primary enterprise tool for business users to create and distribute interactive reports and dashboards independently.

The Deny effect actively intercepts resource creation or update requests and compares the request against the policy rule. If the condition matches, Azure returns a 403 Forbidden error, preventing the resource from being provisioned. This is the correct effect when the requirement is to block non-compliant resources, because it enforces the policy at request time and does not allow the deployment to continue.

Azure SQL Database is a fully managed PaaS relational database built on the SQL Server engine, offering the full T-SQL language, complex joins, stored procedures, and ACID-compliant transactions. It delivers strong consistency by default, guaranteeing that every query sees the latest committed data, which is essential for retail operations like order management and inventory control. Its relational and transactional capabilities make it the natural choice for a transactional data solution that does not require the massive scale-out of analytics engines.

With a columnar layout, each column is stored contiguously, so a query that needs only a few of a wide table's many columns can read exactly those column segments from disk. This drastically lowers I/O traffic and memory consumption compared to row-oriented storage, where the whole row must be pulled even when only one attribute is needed. Because analytics queries tend to aggregate a small subset of columns over huge numbers of rows, this column pruning is a major performance advantage.

The registrar's data has a fixed set of attributes per student, a mandatory unique identifier, and predictable filtering by major. A relational model with a declared schema enforces column types and a primary key constraint, ensuring every row has a valid unique student ID. This directly matches the stated requirement that no record exists without a valid student ID.

Atomicity is the ACID property that treats the entire fund transfer—debit source account and credit destination account—as one indivisible unit. If either SQL statement succeeds while the other fails, the transaction manager issues a rollback, discarding the partial write and restoring the original balances. Without this all-or-nothing guarantee, a bank could lose money or create funds from nothing during a network or application failure.

In OLTP systems, transactional data is workload-optimized for high-frequency write operations using row-based storage, normalization to minimize redundancy, and fast lookup indexes to support ACID-compliant record-level changes. In contrast, analytical data in OLAP systems is structured for complex read patterns, using columnar storage, denormalized schemas, and pre-aggregated measures to speed up queries across large volumes. This fundamental separation drives the design of data pipelines and database engines.

Semi-structured data does not enforce a strict schema but uses tags, keys, or markers to give the data some organizational structure. In this scenario, the truck sensor data arrives as JSON, where each document has name-value pairs but the presence and combination of fields can vary, making it self-describing. These properties—some structure, but no rigid tabular schema—are exactly what define semi-structured data, so this is the correct classification.

Azure SQL Database provides strong ACID transactions for orders. Cosmos DB with NoSQL API offers flexible schema and low-latency reads for the product catalog. Azure Cache for Redis delivers sub-millisecond key-value lookups ideal for session state with eventual consistency.

Power BI is the correct answer because it is Microsoft's dedicated business analytics platform, with Power BI Desktop for modeling and the Power BI Service for publishing live dashboards. It supports real-time scenarios through DirectQuery, push datasets, streaming datasets, and automatic page refresh, integrating with services like Azure Stream Analytics and Event Hubs. These dashboards offer interactive cross-filtering, natural-language Q&A, and row-level security, making them suitable for operational monitoring.

This is correct. Source 1 is a CSV file with fixed columns and defined data types per column, satisfying the rigid schema that defines structured data. Source 2 is JSON with varying fields; it has key-value pairs and hierarchical organization but no fixed schema, so it is semi-structured. Source 3 is TIFF images, which are binary pixel arrays without embedded field names or relational structure, making them unstructured.

SQL tables enforce a rigid schema via predefined columns and data types, so every row must conform to that fixed structure, which is the definition of structured data. A JPEG file is a binary image format that stores encoded pixel data and metadata; it has no row/column organization or queryable schema, making it unstructured. JSON documents use key-value pairs and can have optional or nested fields, so they are self-describing and flexible, which is classic semi-structured data. Thus, all three classifications here are accurate.

Unstructured data has no predefined data model or schema and includes binary files like images, videos, and audio recordings. An MRI scan is exactly that—a binary blob—where the pixel data is not inherently organized into rows/columns, and meaning must be extracted via computer vision or human interpretation, making it a classic example of unstructured data.

Azure Synapse Serverless SQL pool is the correct choice because it is a compute-on-demand query endpoint that runs T-SQL directly over files in Azure Blob Storage or Data Lake Storage Gen2. It uses a distributed query engine to read semi-structured and structured formats like Parquet, Delta, and CSV without any data movement or provisioning of dedicated resources. You can issue standard SELECT statements and let the service scale compute automatically, making it ideal for ad-hoc exploration of large datasets.

The billing analysts need complex joins and guaranteed consistency when several tables are updated together. A relational transactional workload provides ACID semantics, so a multi-table update either fully commits or fully rolls back, and queries see a consistent snapshot. This directly satisfies the requirement that results remain consistent during concurrent updates, which non-transactional stores do not guarantee by default.

Azure Cosmos DB is the correct choice because it natively provides turnkey global distribution across Azure regions with multi-region write support, enabling low-latency reads and writes anywhere in the world. It offers single-digit millisecond latency at the 99th percentile, multiple well-defined consistency levels, and SLAs for availability, throughput, and consistency. Its schema-agnostic NoSQL model supports semi-structured data like product catalogs and user profiles, making it purpose-built for globally distributed e-commerce applications.

Cosmos DB's SQL API is the native query language for the NoSQL API, allowing you to query JSON documents with a SQL-like syntax that supports SELECT, WHERE, JOIN, and functions such as VALUE, ARRAY_CONTAINS, and ST_* spatial functions. Queries are executed directly against the Cosmos DB engine, and the service automatically uses its index to efficiently evaluate predicates. This option is correct because it is the built-in query interface specifically designed for data stored in a Cosmos DB NoSQL account.

The role definition is missing `Microsoft.Storage/storageAccounts/read`, which is the control-plane action required to see the storage account in the Azure portal and to list it with tools like ARM API or PowerShell. Even if `dataActions` grant blob read/write, the user cannot discover or view the storage account resource itself, resulting in an authorization failure when attempting to display the account. This missing read permission is the direct cause of the user's inability to see the storage account.

Amazon S3 only accepts requests signed with AWS credentials, specifically AWS IAM identities such as a user or role. To let Microsoft Purview scan an S3 bucket, you must create an IAM role in the AWS account, configure its trust policy to allow the Purview service principal (via an external ID) to assume the role, and attach policies that grant read access to the bucket. The Purview managed identity then uses that IAM role to authenticate, so AWS IAM authentication is the only valid method for this connection.

This classification is correct because the two workloads have fundamentally different processing requirements. Recording each online transaction is an OLTP operation: it involves high-frequency, low-latency writes and reads for individual events, with strict ACID guarantees to ensure data integrity. Generating the monthly report, by contrast, is an OLAP operation: it queries large volumes of accumulated transaction data, applies aggregations, and supports business intelligence analysis, often within a data warehouse environment optimized for complex read-only queries.

Correct. The SQL database contains structured data (rows and columns), JSON files contain semi-structured data (key-value pairs with some schema flexibility), and JPEG files contain unstructured data (no inherent structure). All three categories are represented.

Semi-structured data exhibits organizational properties—such as key-value pairs, tags, and hierarchical nesting—but does not require a uniform, predefined schema across all instances. JSON documents fit this category perfectly because they use explicit keys to define their internal structure, yet the presence and type of those keys can vary from one document to another. This schema-flexibility, combined with inherent self-description, distinguishes semi-structured data from both rigid structured data and completely structureless unstructured data.

A relational customer table has a fixed schema, so every row shares the same defined columns and data types — that is structured data. JSON documents are self-describing: they contain key-value pairs that can vary from document to document, which classifies them as semi-structured. JPEG images store raw pixel and compression metadata without any queryable semantic fields, so they are unstructured. Therefore, this mapping accurately applies the three data categories to the three storage types.

NoSQL databases use a flexible, schema-less data model where each document or item can have its own set of attributes, and fields can be added, removed, or changed without running ALTER TABLE migrations or coordinating schema changes across the team. This flexibility supports evolving data shapes, rapid development cycles, and storing heterogeneous records in the same container, which is especially useful for IoT telemetry, user profiles, and content feeds. Because the database does not enforce a uniform structure, application code governs shape and validation.

Horizontal scalability is a core design goal of NoSQL databases, which distribute data and query load across many commodity servers using sharding and consistent hashing. Unlike a single relational server that must be upgraded vertically (scale-up), NoSQL systems can add more nodes dynamically to handle increased traffic and data volume (scale-out). Azure Cosmos DB, for example, automatically splits partitions based on partition keys and can elastically scale throughput and storage across regions. This makes horizontal scalability a primary advantage for global, high-velocity applications.

This scenario perfectly fits batch processing because the daily sales data from all stores is accumulated over a fixed period and then processed as a single, scheduled bulk job. Batch jobs such as nightly ETL pipelines in Azure Data Factory or scheduled Spark jobs in Azure Databricks ingest a finite, predefined dataset and transform it in one go, making it ideal for periodic reporting and analytics.

Azure Database Migration Service is a purpose-built tool for migrating entire database schema and data to Azure SQL Database, Azure SQL Managed Instance, or SQL Server on Azure Virtual Machines. It performs pre-migration assessments, generates automation scripts, and supports online migrations with minimal downtime via continuous replication. Unlike generic ETL tools, it is optimized for database-specific concerns like constraints, indexes, and transaction consistency.

Because the videos themselves are unstructured binary content, the practical approach is to keep them in Blob Storage and extract searchable attributes such as speaker, topic, and duration into a companion index. That index can be a relational table or a document store, enabling efficient queries. This is the standard pattern for cataloguing unstructured assets while preserving the original files.

Semi-structured data has some organizational structure, such as keys and nested hierarchies, but no rigid schema shared by all records. The JSON drafts match this exactly: fields differ by article type and nesting exists, yet the data is still machine-parseable by key. Azure services such as Azure Blob Storage combined with Azure Synapse Analytics or Azure Cosmos DB handle this format well.

Relational tables enforce a fixed schema of columns, data types, and constraints, which is the defining trait of structured data. JPEG files are binary image encodings with no queryable schema or row/column organization, so they are unstructured. JSON documents use named fields and nested objects but allow fields to vary across documents, making them semi-structured rather than fully rigid or schema-free.

Azure Databricks provides a unified analytics platform with Apache Spark, offering collaborative notebooks, full Git integration, and auto-scaling clusters. It supports both Python and SQL natively, making it ideal for interactive data exploration and large-scale transformation of data stored in Azure Data Lake Storage Gen2. Its managed infrastructure and notebook environment allow data engineers to prepare and process data efficiently, which aligns perfectly with the requirement.

Azure Blob Storage is Microsoft's highly scalable object storage service for unstructured data, including text, binary files, images, videos, and application backups. It organizes data into containers with flat namespaces and supports tiered storage (hot, cool, cold, archive) to optimize cost and access patterns. This makes it a core building block for storing and serving unstructured content at massive scale, which is why it is a correct answer.

Power BI is a business analytics service that natively connects to Azure SQL Database through built-in connectors, enabling you to create interactive dashboards and reports directly from your operational data. It supports DirectQuery and import modes, providing live or cached data access for rich, dynamic visualizations that can be refreshed on demand. With features like row-level security and natural language queries, it is the ideal tool for lightweight, user-facing dashboards at the retail company, offering immediate insights without an intermediate data transformation layer.

GPS ingestion is correctly classified as stream processing because telematics devices emit position records as a continuous, unbounded sequence of events that must be captured and processed with low latency to support live tracking. In contrast, the nightly aggregation job is batch processing because it operates on a bounded, finite set of data already collected, executing on a fixed schedule to compute summaries like daily mileage or route efficiency.

This is the correct classification because OLAP is designed specifically for multidimensional, historical analysis—slicing, dicing, drilling down, and rolling up across dimensions such as time, region, and product. Data is typically stored in columnar, denormalized schemas (star or snowflake) that make full-table scans and aggregations fast, even on billions of rows. A data scientist analyzing historical sales trends matches this analytical workload precisely.

This is correct because the Aggregate transformation in the data flow groups rows by OrderID and applies a count expression, such as count(OrderID), to calculate occurrences per OrderID. Rows with a count greater than 1 are duplicates, allowing the definition to identify (and subsequently remove) duplicate OrderIDs. This matches the requirement to remove duplicate OrderIDs by counting them.

Azure SQL Database provides full ACID transactions with row-level security and compatibility, making it a robust operational store for healthcare applications. Azure Synapse Analytics offers a large-scale analytics platform with dedicated SQL pools, massively parallel processing, and integrated data warehousing, capable of running complex queries across relational and data lake sources. Together they deliver an integrated, high-performance OLTP/OLAP solution that supports transactional integrity and advanced analytics.

JSON is a classic example of semi-structured data. It uses key-value pairs and can have nested structures, but it does not enforce a rigid schema. This flexibility is ideal for IoT payloads where fields may vary over time.

A Kusto query that uses structurally valid operators will fail with a semantic recognition error when it references a table or column that does not exist in the current database or schema. Since the syntax of where, summarize, and top is correct, the most plausible cause is a misspelled table name or an incorrect column name (e.g., a missing quotation mark or wrong casing). Verify the exact schema from the Azure Data Explorer or Log Analytics schema pane to resolve the issue.

Azure Databricks is a managed Apache Spark platform that provides interactive workspaces and clusters for large-scale data processing. It lets you transform data using Python, Scala, SQL, or R, and supports both batch and streaming workloads. This makes it a primary Azure service for complex ETL and ELT transformations, especially when combining structured and unstructured data across data lakes.

Azure Cosmos DB is a multi-model NoSQL database engineered for single-digit-millisecond write/read latency and instant global distribution, making it the right fit for Workload A's transaction-intensive, low-latency requirements (OLTP). Azure Synapse Analytics is a massively parallel processing (MPP) data warehouse with columnar storage and distributed query execution, built specifically for petabyte-scale analytical scans and complex aggregations (OLAP). This pairing cleanly separates transactional and analytical concerns, so each service is applied where its architecture provides the most benefit.

Azure Stream Analytics is a serverless, purpose-built real-time stream processing engine that executes SQL-like continuous queries over data arriving from sources such as Event Hubs, IoT Hub, or Blob storage. It provides sub-second to single-digit-second latency by applying temporal windows (tumbling, hopping, sliding) and supports outputs to Power BI, SQL Database, and other targets, making it the most direct Azure service for real-time analytics.

Azure Synapse Serverless SQL pool is the correct choice because it is a serverless query engine that uses T-SQL to query IoT sensor data directly from Azure Blob Storage in place, without requiring any data movement or ingestion. It leverages OPENROWSET or external tables to read files such as CSV, JSON, or Parquet, and is ideal for ad-hoc or interactive analysis over raw data. You only pay for the amount of data processed, making it a cost-effective, on-demand option for exploring Blob Storage data.

Zone-redundant storage for Azure SQL Database ensures high availability and durability by synchronously replicating data across three Azure availability zones within a region. This architecture guarantees that transactions are durable and data remains accessible even if a single database instance or an entire availability zone fails. The data is protected against zonal outages, satisfying the requirement for durable transactions despite instance failure.

The relational table is the structured component because it imposes a fixed schema of named columns such as product ID and price, each with defined data types and relational constraints. The product descriptions are plain natural-language text files with no predefined fields or data types, so they are unstructured. The product images are binary files (for example, JPEG or PNG) whose content is pixel data with no rows, columns, or queryable schema, making them unstructured as well. Hence the correct classification is structured, unstructured, unstructured.

A relational table is the most structured here because it enforces a fixed schema: each row (customer record) must conform to predefined columns, data types, and constraints such as primary keys or NOT NULL, enabling rigorous integrity and efficient querying. JSON documents are semi-structured because they consist of key-value pairs and nested objects that can vary across documents—there is no required uniform schema, but the names and types of fields provide intrinsic structure. JPEG files are unstructured binary data; their pixel and compression bytes contain no self-describing fields that a database query engine can interpret as discrete attributes. Thus the descending order fixed-schema table → flexible-schema JSON → schema-less binary JPEG is correct.

Active geo-replication is the correct answer because it provisions a readable secondary database in a different Azure region, with continuous asynchronous data movement from the primary. The secondary can be queried with its own connection string, making it ideal for read-only reporting and analytics while offloading the primary's workload. Because the secondary is a fully accessible online database, it satisfies the requirement for a maintainable read-only copy.

Azure Logic Apps is a cloud service designed for workflow automation and data integration across disparate systems. It provides prebuilt connectors for hundreds of services and enables you to orchestrate data flows using triggers and actions without writing code. This makes it a first-class tool for integrating data between applications and services, which is why it is a correct answer for this question.

When you set a container's public access level to `None`, you disable anonymous access, meaning any request must present valid credentials such as an account key, shared access signature (SAS), or an Azure AD identity with appropriate RBAC role assignments. Authorized users are then the only parties who can read or list blobs in that container. This is the direct function of the `publicAccess` property in the ARM template.

Azure Data Lake Storage Gen2 combines the massive, low-cost capacity of Azure Blob Storage with a hierarchical namespace and POSIX-style access control lists, making it ideal for storing raw and curated IoT data at petabyte scale. Append-only files are written sequentially without update-in-place costs, and because storage is decoupled from compute you can run serverless analytics or spin up Spark clusters only when needed. It integrates natively with Azure Synapse Analytics, Azure Databricks, and HDInsight, enabling schema-on-read processing over Parquet or Delta Lake files. For a historical IoT sensor archive, this is the correct foundation because it makes analytics practical and economical.

Real-time streaming workloads handle continuous data flows that are processed as soon as they arrive, often with low latency requirements. The hospital's IoT sensors generate data every minute that must be acted on promptly, making this a clear example of a real-time streaming workload.

Atomicity treats a transaction as an indivisible unit of work: every statement inside it must succeed for any of them to be applied. If any step fails, a rollback undoes all prior changes, restoring the pre-transaction state. This all-or-nothing property is enforced by database recovery mechanisms such as write-ahead logging or undo segments, ensuring no partial updates survive. Thus, it directly answers the question about a transaction either completing fully or not at all.

Streaming processing is the correct choice because it ingests and analyzes data continuously as it arrives, rather than waiting for a complete dataset. For real-time IoT sensor feeds, services like Azure Stream Analytics can process event streams with sub-second latency, applying time-windowed aggregations, filters, and anomaly detection logic to trigger immediate alerts. This supports proactive failure prediction and operational monitoring, which is impossible with store-then-process approaches.

Eventual consistency allows updates to propagate asynchronously to replicas, guaranteeing that if no further updates occur, all replicas will return the same value after a short period. This matches the requirement of reflecting the update within a few seconds.

Order processing is OLTP because each customer order is a discrete transactional unit—creating, updating, and querying order records with ACID guarantees and low-latency, high-concurrency operations. Weekly reporting is OLAP because it requires complex aggregations and analytical scans over large historical order datasets, a pattern optimized in columnar or data warehouse systems. This correctly distinguishes the two common data workload patterns based on access pattern and purpose.

Azure Data Factory is the correct choice because it is a cloud-based ETL and data integration service purpose-built for orchestrating and automating data movement. It provides a self-hosted integration runtime that securely connects to on-premises SQL Server databases, and its schedule triggers can run pipelines every hour with minimal latency. The service is designed specifically for copying data from sources like on-premises SQL Server to cloud destinations, making it the ideal tool for this workload.

Structured data conforms to a rigid, predefined schema, typically organized into rows and columns. In a SQL Server database, the customer table enforces data types, constraints, and relationships, enabling efficient querying via SQL. This fixed tabular format is the hallmark of structured data.

Azure Event Hubs is a fully managed, highly scalable event ingestion service that accepts millions of events per second from diverse publishers, including social media APIs. It provides partitioned streams with configurable retention, enabling multiple independent consumers to read the same events through separate consumer groups. Its AMQP and Kafka-compatible endpoints make it the standard real-time ingestion front door for high-volume social media feeds.

Structured data is correct because the data is stored in a SQL Server table with a fixed schema: every row must conform to predefined column names, data types, and constraints. This rigid, table-based organization allows efficient indexing, querying, and integrity enforcement, making it the textbook definition of structured data. The term directly contrasts with semi-structured and unstructured data, both of which lack such a uniform, enforced schema.

Structured data adheres to a predefined schema, with each record consisting of named columns that enforce specific data types and constraints. In a retail customer database, tables store fields such as CustomerID, FirstName, LastName, and Email, making the data easily queryable using SQL. This fixed, tabular arrangement is precisely what classifies it as structured data.

Semi-structured data has organizational properties such as tags, keys, or hierarchies but does not enforce a uniform schema on every record. A JSON file of customer orders fits this definition: each order is a document with key-value pairs, nested objects, and optional properties like shipping_address, while the overall set of documents can vary in shape. This is the correct structural category.