CCNA Dap Data Concepts Questions

A data lake is designed to store large volumes of raw data in its native format (structured, semi-structured, or unstructured) without requiring a predefined schema. This makes it ideal for future analytics where the data schema may not yet be known, as it supports schema-on-read rather than schema-on-write.

The data is ordinal because the satisfaction levels have a clear, ordered ranking from 'Very Unsatisfied' to 'Very Satisfied', but the intervals between categories are not necessarily equal. This type of categorical data preserves the order without assuming a consistent numerical difference between each level.

A document store with an inverted index is purpose-built for full-text search, enabling fast keyword queries across millions of text documents and attachments. It supports text extraction from various file types and scales horizontally. Relational, key-value, and graph databases lack the specialized indexing and search features needed for efficient full-text retrieval at this scale.

Encoding is the correct data concept because it transforms categorical features (like gender and marital status) into numerical representations (e.g., one-hot encoding, label encoding) that machine learning algorithms can process. Unlike feature scaling or dimensionality reduction, encoding directly addresses the incompatibility of non-numeric data with mathematical model operations.

A composite B-tree index on (department_id, hire_date) is most effective because it allows the database to satisfy equality and range predicates on both columns in a single index scan. B-tree indexes are optimized for high-cardinality columns and support efficient multi-column filtering when the leading column matches the query's equality condition, followed by the range condition on hire_date.

Validity refers to whether data values conform to the defined format, type, and allowable range for a field. 'N/A', 'unknown', and negative numbers in an Age column violate the expected numeric, non-negative domain, so validity is the primary dimension affected.

Customer feedback comments are qualitative data because they consist of non-numerical, descriptive text that captures opinions, sentiments, or experiences. Unlike quantitative data, which can be measured or counted, qualitative data is categorical and often requires thematic analysis to derive insights.

When foreign key values in the orders table fail to match primary keys in the customer table, the relationship between the tables is broken, which is a referential integrity violation. That is why the join loses rows. Accuracy, completeness, and timeliness describe other properties of data and do not capture a missing parent record for a valid-looking child key.

Tenure is the elapsed time between an employee's hire date and the present. Because the hire date is already stored as a native date type, the analyst can compute the difference directly without any conversion. The birthdate column's text format is a separate data quality issue that does not affect the tenure calculation and should not block it.

A foreign key enforces referential integrity by ensuring that every value in the foreign key column of the 'enrollments' table matches a valid primary key value in the 'students' table. This prevents orphaned records and maintains consistency across related tables in a normalized relational database.

An Avro schema explicitly defines the structure and data types of records before data is written, which is the definition of schema-on-write. The schema is enforced at write time, ensuring data conforms to the defined format when stored. This contrasts with schema-on-read, where structure is applied only when data is queried.

A NoSQL document database is the best choice because it handles semi-structured data with flexible schemas, supports high-speed ingestion, and scales horizontally. It often provides SQL-like query capabilities. Relational databases are too rigid, data warehouses are for structured historical data, and graph databases are for relationship-heavy use cases.

The described environment requires unique identifiers, joins across multiple related tables, and enforced referential integrity. These are defining characteristics of a normalized relational model using primary and foreign keys. Alternative models either lack join capabilities or do not enforce integrity constraints, making them unsuitable for this healthcare analytics scenario.

A LEFT JOIN returns all rows from the left table (customers) and matching rows from the right table (orders). If a customer has no orders, the order columns will contain NULLs. This satisfies the requirement to include all customers, even those without orders.

A data warehouse is optimized for complex queries on structured data because it uses a schema-on-write approach, where data is cleaned, transformed, and organized into relational tables (e.g., star or snowflake schemas) before loading. This pre-processing enables efficient execution of aggregations, joins, and reporting queries using SQL, making it ideal for business intelligence and analytics. In contrast, data lakes store raw data in native formats and rely on schema-on-read, which is less performant for structured query patterns.

A data lake stores data in its native format and applies schema-on-read, allowing raw data to be stored without upfront transformation. These two characteristics enable flexibility and support diverse data types. Enforcing schema-on-write, pre-storage transformation, and optimization for transactional processing are not core to data lakes.

A key-value store like Redis is optimized for extremely low-latency reads and writes using in-memory data structures, making it ideal for high-velocity clickstream ingestion and fast key-value lookups (e.g., session state, counters, real-time analytics). Its simple key→value model avoids the overhead of document parsing or wide-column coordination, delivering sub-millisecond performance.

JSON and XML are examples of semi-structured data, which has a flexible schema unlike structured data (fixed schema) or unstructured data (no schema).

Representing missing fields as null in the JSON object preserves the data structure and allows downstream systems to explicitly handle null values. This approach maintains data integrity without discarding records or introducing ambiguous placeholder strings that could be misinterpreted as actual data.

To retrieve total sales for each product category, you need to join the fact table with the product dimension table to map product keys to categories, and with the time dimension table to filter on the last month. An inner join is correct because it returns only rows where matching keys exist in both tables, which is the standard approach for star-schema queries where all required dimension attributes are present. This ensures that only valid sales transactions with corresponding product and time entries are included in the aggregation.

Temperature measured in Celsius has an arbitrary zero point (0°C does not mean 'no heat'), so it is interval data. Wind speed in meters per second has a true zero point (0 m/s means no wind), making it ratio data. Therefore, option D correctly identifies temperature as interval and wind speed as ratio.

Streaming data is inherently unbounded and infinite because social media feeds generate a continuous, never-ending flow of events. Unlike batch data, there is no natural end to the stream; new tweets, posts, or interactions arrive constantly, making the dataset theoretically infinite in size.

'favorite brand' is a categorical label (qualitative data), while 'units purchased per year' is a numerical count (quantitative data). The question explicitly pairs these two distinct data types, matching the definition of qualitative (non-numeric categories) and quantitative (numeric measurements).

Atomicity is the ACID property that guarantees a transaction is treated as a single indivisible unit — either all of its operations commit or none of them do. If any statement in the transaction fails, the entire transaction is rolled back, leaving the database in its pre-transaction state. This is the 'all-or-nothing' guarantee that the question describes.

The star schema is most efficient for this workload because it denormalizes lookup tables into dimension tables, reducing the number of joins required for aggregations. This design optimizes query performance for large historical datasets by enabling faster full table scans and simpler query plans, which is critical for financial applications needing rapid aggregations.

(ELT) because the company wants to load raw data first and then transform it later, reducing initial processing time. ELT leverages the power of modern data warehouses to perform transformations after loading, which is ideal for rapidly growing volumes of raw transaction data.

Distance and speed between consecutive pings are order-dependent calculations, so the pings must first be sorted by timestamp within each device to form a proper time series. Unit conversion, privacy masking, and daily aggregation are either later steps or would prevent the calculation entirely. Correct sequencing is the foundation for valid deltas.

The exhibit shows an access control policy that grants the DataAnalyst user read permission on the production folder, but includes an explicit deny rule for the sensitive subfolder specified via a path condition. In most access control systems, explicit deny rules take precedence over allow rules, so the deny on the sensitive subfolder overrides the allow on the production folder, effectively blocking read access to objects in the sensitive subfolder while permitting reads elsewhere in the production folder.

ELT (Extract, Load, Transform) loads raw data first, then transforms it inside the data warehouse, as opposed to ETL which transforms before loading.

Duplicate customer IDs violate the uniqueness dimension because uniqueness ensures that each record in a dataset has a distinct identifier with no duplicates. In an ETL process, a primary key or unique constraint on the customer ID column would reject duplicate values, causing the data quality check to fail. This is distinct from consistency, which checks for logical agreement across data sources.

Letter grades are ordinal because they are ranked but have unequal intervals, and tuition amounts are ratio because they have a true zero and support meaningful ratio comparisons. Correctly identifying these scales determines which statistics and visualizations are valid for each field.

The workload is dominated by large aggregate scans over historical telemetry with few updates, which suits a columnar analytical store. Columnar storage reads only the referenced columns and compresses repetitive values, cutting I/O dramatically compared with row-oriented storage, while the rare updates do not conflict with the columnar write pattern.

The data analyst is primarily concerned with consistency, which ensures that the same data values are represented uniformly across different systems or databases. In this scenario, the customer's address must follow the same format (e.g., street, city, state, ZIP code) in every database to enable reliable merging and querying. Consistency is a key data quality dimension that focuses on cross-system uniformity, distinct from accuracy (correctness of values) or completeness (presence of all required fields).

In the context of a relational database, a column represents an attribute of an entity. The 'Name' column stores a specific characteristic (the customer's name) for each row, making it an attribute. This aligns with the data modeling concept where attributes define the properties of an entity.

Consistency is a common dimension of data quality because it ensures that data values are uniform across different datasets or systems, preventing contradictions. For example, if a customer's address is stored as '123 Main St' in one database and '123 Main Street' in another, consistency rules would flag this discrepancy. This dimension is critical for reliable reporting and integration.

Increasing the VARCHAR length of dim_account.account_type to accommodate the longest account type (e.g., VARCHAR(15) for 'CheckingPremium') resolves the data truncation error without data loss. This aligns with the star schema design principle of preserving source data integrity while ensuring the column definition matches the actual data length. The team must avoid truncation or NULL insertion to maintain accurate dimensional attributes for analytics.

A dimensional star schema is designed for analytical workloads, using fact and dimension tables to minimize joins and optimize aggregations. It supports columnar storage and partitioning, which are critical for terabyte-scale read-heavy queries. Normalized OLTP, EAV, and flat files each introduce performance bottlenecks or lack the necessary optimizations for complex analytical queries on historical stock trades.

A foreign key constraint enforces referential integrity by requiring that values in a column match values in the primary key (or unique key) column of another table. This is exactly the rule described — ensuring every value in one table's column corresponds to a primary key value in another table.

To perform time-series analysis on a date string, the analyst must first convert it to a proper date data type so that date functions can be applied. Additionally, creating separate month and year columns simplifies grouping and aggregation for monthly trends. These two steps ensure the data is in a usable format for temporal analysis.

The table violates First Normal Form (1NF) because it contains repeating groups (Product1, Product1Qty, Product2, Product2Qty) instead of storing each product in a separate row. 1NF requires that each column contains atomic values and that there are no repeating groups or arrays. The presence of multiple product columns for a single order breaks this atomicity and normalization rule.

The HAVING clause filters groups after aggregation, so it operates on aggregated values like COUNT(*), SUM(), or AVG(). In the exhibit, the query likely uses HAVING COUNT(order_id) > 5, which excludes customers with exactly 5 orders because the condition is strictly greater than 5. This illustrates aggregation with post-aggregation filtering, distinct from WHERE, which filters rows before grouping.

The correct answer is Ordinal because the classifications have a natural order (Freshman, Sophomore, Junior, Senior) but the differences between them are not equal or measurable. Nominal would ignore the order, while interval and ratio require quantitative properties that are absent here.

The blood pressure categories have a clear rank order from lowest to highest risk but lack equal intervals or a true zero, which is the defining characteristic of ordinal data. Nominal data would ignore the ranking, while interval and ratio scales require numeric properties that these qualitative labels do not possess.

B is correct because the scenario describes data arriving continuously in small batches that must be processed in real-time for monitoring. This is the defining characteristic of streaming data, which is typically ingested via technologies like Apache Kafka, Amazon Kinesis, or MQTT brokers, enabling low-latency processing and immediate alerting.

Using a placeholder like 'Unknown' for categorical missing data preserves the dataset's structure and allows analysis to proceed without introducing statistical bias. This method is particularly valid for nominal data where the missing category can be treated as a distinct value, enabling downstream operations like one-hot encoding or frequency analysis without distorting the original distribution.

A data lake is designed to store raw data in its native format, including unstructured and semi-structured data from IoT sensors, without requiring a predefined schema. This allows the organization to preserve the original data for future analysis, unlike traditional databases that enforce structure upon ingestion.

An image file is unstructured data because it has no predefined data model or schema — its content is raw pixel data that requires specialized processing (e.g., computer vision) to extract meaning. This contrasts with structured formats that organize data into rows, columns, or key-value pairs.

The data owner is the senior manager accountable for a specific data asset, including its quality, definition, and compliance. In the DA0-001 context, the data owner has ultimate responsibility for the data, not just day-to-day management. This role ensures consistent definitions and quality across the organization, aligning with the governance team's objectives.

The requirements combine high-velocity ingestion, absence of predefined schema, and support for semi-structured payloads with later analytical querying. Document-oriented NoSQL databases provide schema-on-read flexibility and horizontal write scalability that match these needs. Relational, columnar, and graph systems each impose constraints or optimizations that conflict with one or more of the stated requirements.

A composite index on (CustomerID, OrderDate) allows the database to satisfy queries that filter on both columns using a single index seek, avoiding a full table scan or multiple index lookups. The column order matters: CustomerID first supports equality filtering, and OrderDate second supports range or sort operations within each customer. This is the most direct performance improvement for the described query pattern.

Accuracy measures how well data reflects real-world values or a defined standard. Here, 20% of completed fields contain values outside valid ranges, meaning the data is present but incorrect, directly degrading accuracy. Completeness (95% filled) is high, but the core issue is that the values themselves are wrong, not missing or late.

Standardizing date formats across all tables (Option B) ensures that date values are stored and interpreted uniformly, eliminating inconsistencies that arise from mixed formats (e.g., MM/DD/YYYY vs. DD-MM-YY). This practice directly supports data consistency by enforcing a single representation, which is critical for accurate querying, reporting, and integration across systems.

The correct answer is Data lake because it can store raw data in any format, scale horizontally, and handle high write throughput. Relational databases, data warehouses, and OLTP databases are optimized for structured data and transactional workloads, making them less suitable for diverse, high-volume healthcare data.

The team needs a schema-flexible structure that can hold nested and variable attributes, such as allergy lists and changing lab results, while allowing new fields to be added without migrations. A document model provides exactly this by storing each patient record as a self-contained, nested document that evolves with clinical requirements.

Blood type is a categorical label that identifies which of the recognized blood groups a patient belongs to. There is no inherent order among A+, O-, AB+, and B-, and no arithmetic can be meaningfully performed on these values. Nominal classification is the only correct choice because it groups data into unordered, distinct categories.

Data quality management is the governance function specifically responsible for defining data quality dimensions (accuracy, completeness, consistency, timeliness, validity, uniqueness) and implementing the rules, profiling, and monitoring to enforce them. It translates governance policy into measurable quality controls and remediation workflows.

Web scraping often involves accessing data that may be protected by copyright, terms of service, or privacy regulations such as GDPR or the Computer Fraud and Abuse Act (CFAA). Even if data is publicly accessible, repurposing it for market research without permission can lead to legal liability or ethical violations, making this a fundamental challenge.

The field 'region' contains categorical labels (e.g., 'North', 'South', 'East', 'West') that represent distinct groups or categories, not numerical measurements. Qualitative data (also called categorical data) describes attributes or characteristics that can be named but not meaningfully ordered or measured on a numeric scale. Since 'region' assigns a name to a geographic area without any inherent numeric value or order, it is a classic example of qualitative data.

A document database provides schema flexibility by storing each user profile as a self-contained document, allowing new attributes to be added without global schema changes or downtime. Relational databases require migrations, key-value stores lack query flexibility, and graph databases are optimized for relationships rather than evolving profile attributes.

Processing is the stage where raw data is transformed into a usable format through cleaning, validation, normalization, or aggregation. This step ensures data quality and consistency before analysis or storage, directly matching the question's description.

Retrieving data from a REST API that returns JSON is a classic example of data ingestion, where data is acquired from an external source and brought into a system for processing or storage. This step is part of the data lifecycle's initial phase, often called data acquisition or ingestion. The other options—archival, sharing, and deletion—occur later in the lifecycle after data has been ingested and processed.

The level of granularity refers to the finest detail captured in the dataset. Since the data contains daily patient visits, each record represents a single visit event, not the patient or the day itself. Therefore, 'Visit' is the correct granularity because each row corresponds to one visit occurrence.

OLTP databases are optimized for high-frequency write operations (INSERT/UPDATE/DELETE) and ACID compliance, making them ideal for transaction processing but poor for complex analytical queries. In contrast, a data warehouse is optimized for read-heavy OLAP workloads, using columnar storage, pre-aggregated tables, and indexing strategies that enable fast aggregation and trend analysis over large historical datasets. This architectural difference directly supports the retail company's need to analyze purchase trends over time.

A data lake is designed to store raw, unprocessed data in its native format without requiring a predefined schema, which is exactly what is needed for IoT sensor data whose schema is not yet defined. It supports schema-on-read, allowing analytics projects to interpret the data later as requirements evolve. This makes it the most appropriate choice for storing diverse, high-volume raw data for future analytics.

Atomicity guarantees that a transaction is treated as a single unit, completed entirely or not at all.

Customer names are categorical labels that identify individuals without any inherent order or numerical value. This fits the definition of nominal data, which is used for naming or classifying variables. In data analysis, nominal data can be stored as strings and used for grouping or filtering, but arithmetic operations are meaningless.

The scenario describes storing shipment records under unique identifiers with varying attributes and no fixed schema, which is the defining characteristic of a key-value store. Key-value stores excel at fast, simple lookups by key, making them ideal for caching real-time tracking updates. Relational databases, warehouses, and lakes impose structure or latency that conflict with these requirements.