CCNA Describe core data concepts Questions

Locally-redundant storage (LRS) writes three synchronous copies of your customer data within a single physical data center in the primary Azure region. Every replica remains inside the same datacenter and region, so no data is ever replicated across availability-zone or regional boundaries, satisfying strict data-residency requirements. LRS is the lowest-cost redundancy tier that still provides a durable copy when the requirement is simply to keep data in one geography.

OLTP (Online Transaction Processing) is the correct workload type for the immediate trip-request workflow: each request creates or updates a small, atomic transaction with high concurrency and fast response times. OLAP (Online Analytical Processing) correctly describes the monthly reporting and aggregation workload, which scans and aggregates large volumes of historical trip data for business analysis. Together they identify the operational versus analytical workload split the question is asking about, rather than data movement patterns or storage models.

Relational tables enforce a rigid schema with predefined columns, data types, and constraints, making them the most structured form. JSON documents use key-value pairs and nested objects but permit varying fields across documents, classifying them as semi-structured. Image files are raw binary streams with no inherent schema or semantic structure, therefore unstructured. This ordering correctly progresses from highest to lowest structural organization.

Azure Data Explorer (ADX) is a fully managed, high-performance analytics service built specifically for near real-time telemetry, logs, and time-series data, using the Kusto Query Language (KQL) to filter, aggregate, and join events. It ingests data directly from Event Hubs and IoT Hub with low latency, and its columnar index and sharding design support sub-second query responses on massive streams of append-only data. This combination of rapid ingestion, optimized storage, and fast query execution directly satisfies the requirement for a sub-second analytical solution on streaming data.

Batch processing executes data transformation and loading as discrete, scheduled jobs that operate on a finite set of data accumulated over time. In this scenario, store sales data is uploaded at the end of each business day, and an Azure Data Factory pipeline runs on a fixed schedule to transform and load it into Azure Synapse Analytics. This matches a typical ETL batch pattern, providing predictable, cost-efficient processing while trading off latency — results are ready the next morning, not instantly.

The Core (SQL) API is the native and default API for Azure Cosmos DB, optimized for querying JSON documents using a SQL query dialect. It supports familiar relational constructs such as SELECT, WHERE, JOIN, and GROUP BY, adapted to work on schema-flexible NoSQL data. This makes it the only API that directly accepts SQL queries without translation or compatibility layers.

Streaming processing is purpose-built for real-time data: it ingests events continuously from sources like Azure Event Hubs or IoT Hub and processes them as they arrive, often with sub-second latency. This architecture enables real-time dashboards, anomaly alerts, and event-driven responses where decisions must be made on the latest data. For example, a streaming pipeline might aggregate clickstream events into 5-second windows to show current user activity, which is impossible with batch processing that defers computation until a scheduled run.

The HAVING clause is used to filter groups after aggregation has been performed. In the query shown, the GROUP BY clause likely groups rows by one or more columns, and then HAVING applies a condition to the aggregated TotalSales value (e.g., HAVING SUM(TotalSales) > 1000) to keep only certain groups. This differs from WHERE, which cannot reference aggregate functions, whereas HAVING is evaluated after GROUP BY and can directly test SUM, COUNT, AVG, and other aggregate results.

Semi-structured data, such as JSON, XML, or key-value pairs, uses tags or markers to separate elements and permits schema flexibility. Vital signs readings naturally fit this model because each reading can include a variable set of measured parameters (e.g., some include SpO2, some include respiratory rate) without requiring every record to have identical fields, and the order of fields does not matter.

Azure Data Factory is the correct choice because its mapping data flows provide a visual, code-free environment for designing ETL transformations by connecting source and sink datasets and arranging transformation activities on a canvas. These data flows execute on a managed Spark cluster, allowing complex joins, aggregations, and derived columns to be built declaratively without writing any code, making it the core ETL service for a data warehouse in Azure.

Referential integrity is a database constraint enforced by foreign keys: it guarantees that every value in a foreign key column exactly matches an existing primary key value in the referenced table, thereby preventing orphaned rows. This rule is precisely what the scenario describes—the relational database uses these key relationships to maintain valid associations between customer records and related tables.

Archive tier offers the lowest storage cost of any Blob Storage tier, ideal for data that is seldom accessed and due for long-term retention. It accepts retrieval latency of up to 15 hours and carries a minimum 180-day storage commitment, making it perfect for dormant customer transaction records that must be preserved for compliance. This is why it is the correct selection.

A financial transfer that debits one account and credits another touches two independent storage systems. Distributed transaction coordination—via a two-phase commit or a saga pattern with compensating actions—ensures atomicity across those stores, so a failure in one step does not leave a partial, inconsistent state. Without such coordination, one side could commit while the other fails, causing account balances to diverge and require manual reconciliation.

Relational database tables are structured because they enforce a fixed schema with defined columns and data types, allowing straightforward SQL queries. JSON is semi-structured since it uses self-describing key-value pairs that can vary from record to record, lacking a rigid schema. Binary image files are unstructured as they contain raw pixel data with no inherent organization or queryable structure, completing the correct classification.

Structured data is inherently organised with a predefined schema, which mandates its storage in a highly organised format. This characteristic directly aligns with being stored in rows and columns, a hallmark of relational databases. Each row represents a unique record, while columns define specific attributes or fields, ensuring data consistency and enabling efficient querying and analysis. This precise tabular structure is a defining feature of structured data, satisfying the requirement for its organised nature.

Always Encrypted encrypts selected columns client-side using a column encryption key protected by a column master key held outside Azure SQL Database. The database engine stores and processes only ciphertext, so sensitive data is never exposed to SQL Server administrators or to Azure personnel. With deterministic encryption the server can support equality operations (e.g., WHERE clauses and joins) while randomized encryption avoids leaks. The client application and driver must be compatible, and the application must supply the keys.

Azure Data Factory is correct because it represents linked services, datasets, and pipelines as JSON objects. The exhibit shows a linked service definition with a type and typeProperties containing connection details, which is the standard way ADF stores source and destination connection information. This serialized JSON enables version-controlled, repeatable deployment of data integration artifacts.

Azure Stream Analytics is a fully managed, purpose-built stream-processing service that handles near real-time IoT telemetry with low latency. It provides a SQL-like query language that natively supports temporal windows, sliding windows, and event-time processing, allowing filters, aggregations, and even anomaly detection directly on the stream. Crucially, it has a native Cosmos DB sink and built-in connectors to Event Hubs, IoT Hub, and other Azure services, eliminating the need for custom glue code. Because it processes each event as it arrives rather than in micro-batches, it is the ideal choice for real-time IoT scenarios that require prompt alerts or continuous output.

Structured data has a fixed, predefined schema: every row in this POS dataset contains the same columns (TransactionID, ProductID, Quantity, Price) with consistent data types, allowing direct querying with SQL. This tabular format—organized into rows and columns with strict formatting—is the defining characteristic of structured data. Because the schema is known ahead of time and every record conforms to it, this dataset clearly fits the structured data classification.

Relational tables enforce a fixed schema, making them most structured. JSON documents are semi-structured, since fields vary between records. JPEG images are unstructured, holding no schema or queryable field structure, so this ordering runs correctly from most to least structured.

Customer records in a relational table are strictly structured (fixed schema), product reviews as JSON are semi-structured (schema-on-read), and marketing images are unstructured (binary files). This is the correct order from most to least structured.

Archive Blob Storage is the correct choice because it offers the lowest storage cost of any Azure Blob access tier, which aligns with the archival requirement. Data is stored offline without instant access, but the service supports rehydration within up to 15 hours—well within the stated 24-hour retrieval window. The latency is acceptable here because the workload prioritizes cost minimization over immediate availability.

OLTP and OLAP are the two standard workload categories in data processing. OLTP systems handle high-volume, low-latency transactional operations such as order entry and inventory updates, emphasizing ACID guarantees and row-level integrity. OLAP systems support analytical queries that aggregate and summarize large historical datasets, often using columnar storage and multidimensional schemas for business intelligence. Together they capture the fundamental divide between running day-to-day operations and analyzing those operations afterward.

Azure Databricks is an Apache Spark-based analytics platform that offers collaborative notebooks, autoscaling clusters, and supports Python, Scala, SQL, and R. It allows data engineers to read CSV files from Azure Data Lake Storage or Blob storage, perform complex transformations using DataFrames or SQL, and write results back — exactly the code-first, scalable batch processing required for a global e-commerce workload. Its serverless option removes infrastructure management while providing the flexibility to write custom transformation logic in Python, making it the ideal choice.

Schema-on-read applies a logical structure to data only when it is accessed by a query engine, such as Azure Synapse Serverless SQL, Spark, or a metastore catalog that overlays schema metadata on raw files. Raw log files can be stored as-is in a data lake in open formats like JSON, CSV, or Parquet, and the schema is interpreted or inferred at read time. This is the correct answer because it matches the data engineer's workflow of loading raw files into storage without imposing structure until analysis.

OLTP (Online Transaction Processing) is the correct workload because order placement involves multiple concurrent, short-duration transactions—inserting the order, adjusting inventory, and recording payment—that must each be executed atomically and with ACID guarantees. These systems use row-based, normalized storage to provide fast writes, strict data integrity, and very low response times even under heavy user concurrency. This directly matches the operational need for immediate, reliable processing of each customer action.

Azure Stream Analytics is a fully managed stream-processing service that queries live data using a SQL-like language without requiring custom code. It reads from high-throughput sources such as Event Hubs or IoT Hub, applies temporal windows, filters, joins, and aggregates, and writes results to Power BI, Azure SQL, Cosmos DB, or Data Lake Storage. Its declarative model and built-in time handling make it the natural choice for low-latency social media analytics, letting you continuously compute metrics like mentions, sentiment, or trending hashtags in near-real time.

Lambda architecture is correct because it deliberately combines a batch layer for accurate, comprehensive historical processing and a speed layer for real-time stream processing over the same sensor data. The batch layer computes precise trends and baseline models from all collected data, while the speed layer provides low-latency anomaly detection and feeds both results into a serving layer for unified querying. This design satisfies both the real-time alerting and historical analysis requirements, with the tradeoff of maintaining two separate code paths.

JSON documents consist of key-value pairs, nested objects, and arrays, but each waybill may have a different set of fields—some optional, some nested. This self-describing format provides inherent organization through keys and hierarchical structure, yet it does not enforce a rigid, predefined schema. That combination of organizational properties without a fixed tabular schema is the defining characteristic of semi-structured data, which is why this is the correct classification.