Amazon AWS Certified Data Engineer - Associate DEA-C01 Practice Test 18
Question 170
A database source sees excessive concurrent connections after indiscriminately increasing Glue read partitions. What is the MOST appropriate targeted implementation for this data-engineering situation?
- In this operational case, increase Spark executors without checking JDBC source connections.
- In this operational case, choose supported parallel JDBC partition bounds and fetch sizing that respect source database capacity.
- In this operational case, use a Glue crawler as the database query load balancer.
- In this operational case, assume dividing by a low-cardinality flag creates equal JDBC read partitions.
Explanation
Correct Answer
B:Parallel JDBC extraction can increase throughput but generates concurrent source queries and must avoid skew. Validate with jDBC partition predicates, query plan, active DB sessions, read duration and sampled row counts.
Incorrect Answers
A:Increase Spark executors without checking JDBC source connections. Parallel JDBC extraction can increase throughput but generates concurrent source queries and must avoid skew. Inspect jDBC partition predicates, query plan, active DB sessions, read duration and sampled row counts.
C:Setting maximum parallelism without source-side limits can overload the transaction database. Use a Glue crawler as the database query load balancer.
D:This does not meet JDBC parallel reads and predicate partitioning in Glue. The supported design is to choose supported parallel JDBC partition bounds and fetch sizing that respect source database capacity.
Question 171
A database source sees excessive concurrent connections after indiscriminately increasing Glue read partitions. What diagnostic observations should be checked before marking the change successful?
- The relevant validation evidence is a resource ARN alone without any current data-plane observation.
- The relevant validation evidence is jDBC partition predicates, query plan, active DB sessions, read duration and sampled row counts.
- The relevant validation evidence is a renamed resource label that does not show an authorization or processing result.
- The relevant validation evidence is a browser screenshot from another AWS account and time period.
Explanation
Correct Answer
B:Parallel JDBC extraction can increase throughput but generates concurrent source queries and must avoid skew.
Incorrect Answers
A:A resource ARN alone without any current data-plane observation. This is not sufficient evidence for JDBC parallel reads and predicate partitioning in Glue. Check jDBC partition predicates, query plan, active DB sessions, read duration and sampled row counts. Parallel JDBC extraction can increase throughput but generates concurrent source queries and must avoid skew.
C:A renamed resource label that does not show an authorization or processing result. This is not sufficient evidence for JDBC parallel reads and predicate partitioning in Glue. Check jDBC partition predicates, query plan, active DB sessions, read duration and sampled row counts. Parallel JDBC extraction can increase throughput but generates concurrent source queries and must avoid skew.
D:A browser screenshot from another AWS account and time period. This is not sufficient evidence for JDBC parallel reads and predicate partitioning in Glue. Check jDBC partition predicates, query plan, active DB sessions, read duration and sampled row counts. Parallel JDBC extraction can increase throughput but generates concurrent source queries and must avoid skew.
Question 172
A database source sees excessive concurrent connections after indiscriminately increasing Glue read partitions. What technical statement accurately describes the relevant AWS processing behavior?
- The governing design principle is that a pipeline schedule guarantees that every downstream source record was processed correctly.
- The governing design principle is that parallel JDBC extraction can increase throughput but generates concurrent source queries and must avoid skew.
- The governing design principle is that a CloudWatch metric label is equivalent to a successful target table data-quality validation.
- The governing design principle is that every AWS managed service uses the same consistency, retry and query-processing semantics.
Explanation
Correct Answer
B:This is the relevant technical mechanism for JDBC parallel reads and predicate partitioning in Glue. Verify with jDBC partition predicates, query plan, active DB sessions, read duration and sampled row counts.
Incorrect Answers
A:A pipeline schedule guarantees that every downstream source record was processed correctly. That generalization conflicts with JDBC parallel reads and predicate partitioning in Glue. Instead parallel JDBC extraction can increase throughput but generates concurrent source queries and must avoid skew. Check jDBC partition predicates, query plan, active DB sessions, read duration and sampled row counts.
C:A CloudWatch metric label is equivalent to a successful target table data-quality validation. That generalization conflicts with JDBC parallel reads and predicate partitioning in Glue. Instead parallel JDBC extraction can increase throughput but generates concurrent source queries and must avoid skew. Check jDBC partition predicates, query plan, active DB sessions, read duration and sampled row counts.
D:Every AWS managed service uses the same consistency, retry and query-processing semantics. That generalization conflicts with JDBC parallel reads and predicate partitioning in Glue. Instead parallel JDBC extraction can increase throughput but generates concurrent source queries and must avoid skew. Check jDBC partition predicates, query plan, active DB sessions, read duration and sampled row counts.
Question 173
A database source sees excessive concurrent connections after indiscriminately increasing Glue read partitions. An incorrect proposal is: Assume dividing by a low-cardinality flag creates equal JDBC read partitions. Which failure consequence BEST shows why that proposal is inappropriate?
- The concrete failure is that setting maximum parallelism without source-side limits can overload the transaction database.
- The concrete failure is that the presence of an accurate job timestamp automatically created unauthorized database credentials.
- The concrete failure is that inspecting an existing Athena query plan itself deleted every production table.
- The concrete failure is that a harmless resource display-name edit caused all prior ETL jobs to lose their source schemas.
Explanation
Correct Answer
A:This is why the incorrect shortcut does not meet JDBC parallel reads and predicate partitioning in Glue. The safer implementation is to choose supported parallel JDBC partition bounds and fetch sizing that respect source database capacity.
Incorrect Answers
B:The presence of an accurate job timestamp automatically created unauthorized database credentials. That unrelated assertion does not explain the actual JDBC parallel reads and predicate partitioning in Glue risk. The relevant failure is that setting maximum parallelism without source-side limits can overload the transaction database. Check jDBC partition predicates, query plan, active DB sessions, read duration and sampled row counts.
C:Inspecting an existing Athena query plan itself deleted every production table. That unrelated assertion does not explain the actual JDBC parallel reads and predicate partitioning in Glue risk. The relevant failure is that setting maximum parallelism without source-side limits can overload the transaction database. Check jDBC partition predicates, query plan, active DB sessions, read duration and sampled row counts.
D:A harmless resource display-name edit caused all prior ETL jobs to lose their source schemas. That unrelated assertion does not explain the actual JDBC parallel reads and predicate partitioning in Glue risk. The relevant failure is that setting maximum parallelism without source-side limits can overload the transaction database. Check jDBC partition predicates, query plan, active DB sessions, read duration and sampled row counts.
Question 174
A database source sees excessive concurrent connections after indiscriminately increasing Glue read partitions. The observed failure is: Setting maximum parallelism without source-side limits can overload the transaction database. How should the team correct and verify the observed fault?
- The supported recovery step is to use a Glue crawler as the database query load balancer.
- The supported recovery step is to assume dividing by a low-cardinality flag creates equal JDBC read partitions.
- The supported recovery step is to tune partition bounds and connection count against measured source read pressure and reconcile row totals.
- The supported recovery step is to increase Spark executors without checking JDBC source connections.
Explanation
Correct Answer
C:This addresses the observed JDBC parallel reads and predicate partitioning in Glue failure while preserving the required contract. Recheck jDBC partition predicates, query plan, active DB sessions, read duration and sampled row counts.
Incorrect Answers
A:Use a Glue crawler as the database query load balancer. Setting maximum parallelism without source-side limits can overload the transaction database. Instead tune partition bounds and connection count against measured source read pressure and reconcile row totals.
B:Assume dividing by a low-cardinality flag creates equal JDBC read partitions. Setting maximum parallelism without source-side limits can overload the transaction database. Instead tune partition bounds and connection count against measured source read pressure and reconcile row totals.
D:Increase Spark executors without checking JDBC source connections. Setting maximum parallelism without source-side limits can overload the transaction database. Instead tune partition bounds and connection count against measured source read pressure and reconcile row totals.
Question 175
Athena repeatedly scans terabytes of newline CSV to read only two analytic columns. What is the MOST appropriate targeted implementation for this data-engineering situation?
- Keep all data as uncompressed CSV and assume column pruning works identically.
- Write one Parquet file for every individual event to maximize parallelism.
- Transform row-oriented sources into reasonably sized columnar Parquet files with balanced compression and partition layout.
- Disable compression solely because files already have a date prefix.
Explanation
Correct Answer
C:Columnar storage can reduce scanned bytes through projection and compression, while excessive tiny objects add planning overhead. This directly addresses Parquet columnar conversion and small file compaction.
Incorrect Answers
A:This does not meet Parquet columnar conversion and small file compaction. Converting CSV to Parquet without compacting tiny objects may leave query startup costly.
B:Write one Parquet file for every individual event to maximize parallelism. Columnar storage can reduce scanned bytes through projection and compression, while excessive tiny objects add planning overhead. Inspect athena bytes scanned, Parquet file sizes, compression ratio, object counts and query latency.
D:Converting CSV to Parquet without compacting tiny objects may leave query startup costly. The appropriate action is to transform row-oriented sources into reasonably sized columnar Parquet files with balanced compression and partition layout.
Question 176
Athena repeatedly scans terabytes of newline CSV to read only two analytic columns. What diagnostic observations should be checked before marking the change successful?
- A resource ARN alone without any current data-plane observation.
- A dashboard color with no source event or data row evidence.
- Athena bytes scanned, Parquet file sizes, compression ratio, object counts and query latency.
- A browser screenshot from another AWS account and time period.
Explanation
Correct Answer
C:Columnar storage can reduce scanned bytes through projection and compression, while excessive tiny objects add planning overhead. These observations directly test Parquet columnar conversion and small file compaction.
Incorrect Answers
A:A resource ARN alone without any current data-plane observation. This is not sufficient evidence for Parquet columnar conversion and small file compaction. Check athena bytes scanned, Parquet file sizes, compression ratio, object counts and query latency. Columnar storage can reduce scanned bytes through projection and compression, while excessive tiny objects add planning overhead.
B:A dashboard color with no source event or data row evidence. This is not sufficient evidence for Parquet columnar conversion and small file compaction. Check athena bytes scanned, Parquet file sizes, compression ratio, object counts and query latency. Columnar storage can reduce scanned bytes through projection and compression, while excessive tiny objects add planning overhead.
D:A browser screenshot from another AWS account and time period. This is not sufficient evidence for Parquet columnar conversion and small file compaction. Check athena bytes scanned, Parquet file sizes, compression ratio, object counts and query latency. Columnar storage can reduce scanned bytes through projection and compression, while excessive tiny objects add planning overhead.
Question 177
Athena repeatedly scans terabytes of newline CSV to read only two analytic columns. What technical statement accurately describes the relevant AWS processing behavior?
- An S3 bucket prefix guarantees exactly-once multi-service transactions without an output commit.
- A CloudWatch metric label is equivalent to a successful target table data-quality validation.
- Every AWS managed service uses the same consistency, retry and query-processing semantics.
- Columnar storage can reduce scanned bytes through projection and compression, while excessive tiny objects add planning overhead.
Explanation
Correct Answer
D:Implement by choosing to transform row-oriented sources into reasonably sized columnar Parquet files with balanced compression and partition layout. This is the relevant technical mechanism for Parquet columnar conversion and small file compaction.
Incorrect Answers
A:An S3 bucket prefix guarantees exactly-once multi-service transactions without an output commit. That generalization conflicts with Parquet columnar conversion and small file compaction. Instead columnar storage can reduce scanned bytes through projection and compression, while excessive tiny objects add planning overhead. Check athena bytes scanned, Parquet file sizes, compression ratio, object counts and query latency.
B:A CloudWatch metric label is equivalent to a successful target table data-quality validation. That generalization conflicts with Parquet columnar conversion and small file compaction. Instead columnar storage can reduce scanned bytes through projection and compression, while excessive tiny objects add planning overhead. Check athena bytes scanned, Parquet file sizes, compression ratio, object counts and query latency.
C:Every AWS managed service uses the same consistency, retry and query-processing semantics. That generalization conflicts with Parquet columnar conversion and small file compaction. Instead columnar storage can reduce scanned bytes through projection and compression, while excessive tiny objects add planning overhead. Check athena bytes scanned, Parquet file sizes, compression ratio, object counts and query latency.
Question 178
Athena repeatedly scans terabytes of newline CSV to read only two analytic columns. An incorrect proposal is: Keep all data as uncompressed CSV and assume column pruning works identically. Which failure consequence BEST shows why that proposal is inappropriate?
- The presence of an accurate job timestamp automatically created unauthorized database credentials.
- Inspecting an existing Athena query plan itself deleted every production table.
- The dashboard theme independently caused an unrelated source database failure.
- Converting CSV to Parquet without compacting tiny objects may leave query startup costly.
Explanation
Correct Answer
D:This is why the incorrect shortcut does not meet Parquet columnar conversion and small file compaction. Columnar storage can reduce scanned bytes through projection and compression, while excessive tiny objects add planning overhead.
Incorrect Answers
A:The presence of an accurate job timestamp automatically created unauthorized database credentials. That unrelated assertion does not explain the actual Parquet columnar conversion and small file compaction risk. The relevant failure is that converting CSV to Parquet without compacting tiny objects may leave query startup costly. Check athena bytes scanned, Parquet file sizes, compression ratio, object counts and query latency.
B:Inspecting an existing Athena query plan itself deleted every production table. That unrelated assertion does not explain the actual Parquet columnar conversion and small file compaction risk. The relevant failure is that converting CSV to Parquet without compacting tiny objects may leave query startup costly. Check athena bytes scanned, Parquet file sizes, compression ratio, object counts and query latency.
C:The dashboard theme independently caused an unrelated source database failure. That unrelated assertion does not explain the actual Parquet columnar conversion and small file compaction risk. The relevant failure is that converting CSV to Parquet without compacting tiny objects may leave query startup costly. Check athena bytes scanned, Parquet file sizes, compression ratio, object counts and query latency.
Question 179
Athena repeatedly scans terabytes of newline CSV to read only two analytic columns. The observed failure is: Converting CSV to Parquet without compacting tiny objects may leave query startup costly. How should the team correct and verify the observed fault?
- Compact into appropriately sized Parquet objects and compare Athena scans and representative query plans.
- Write one Parquet file for every individual event to maximize parallelism.
- Disable compression solely because files already have a date prefix.
- Keep all data as uncompressed CSV and assume column pruning works identically.
Explanation
Correct Answer
A:This addresses the observed Parquet columnar conversion and small file compaction failure while preserving the required contract. Columnar storage can reduce scanned bytes through projection and compression, while excessive tiny objects add planning overhead.
Incorrect Answers
B:Write one Parquet file for every individual event to maximize parallelism. Converting CSV to Parquet without compacting tiny objects may leave query startup costly. Instead compact into appropriately sized Parquet objects and compare Athena scans and representative query plans.
C:Disable compression solely because files already have a date prefix. Converting CSV to Parquet without compacting tiny objects may leave query startup costly. Instead compact into appropriately sized Parquet objects and compare Athena scans and representative query plans.
D:Keep all data as uncompressed CSV and assume column pruning works identically. Converting CSV to Parquet without compacting tiny objects may leave query startup costly. Instead compact into appropriately sized Parquet objects and compare Athena scans and representative query plans.
Question 180
Thousands of sub-megabyte Parquet files generate excessive S3 open requests and slow queries. Which controlled service choice should the engineer make to meet this requirement?
- In this operational case, transform row-oriented sources into reasonably sized columnar Parquet files with balanced compression and partition layout.
- In this operational case, write one Parquet file for every individual event to maximize parallelism.
- In this operational case, disable compression solely because files already have a date prefix.
- In this operational case, keep all data as uncompressed CSV and assume column pruning works identically.
Explanation
Correct Answer
A:Columnar storage can reduce scanned bytes through projection and compression, while excessive tiny objects add planning overhead. Validate with athena bytes scanned, Parquet file sizes, compression ratio, object counts and query latency.
Incorrect Answers
B:Write one Parquet file for every individual event to maximize parallelism. Columnar storage can reduce scanned bytes through projection and compression, while excessive tiny objects add planning overhead. Inspect athena bytes scanned, Parquet file sizes, compression ratio, object counts and query latency.
C:Converting CSV to Parquet without compacting tiny objects may leave query startup costly. Disable compression solely because files already have a date prefix.
D:This does not meet Parquet columnar conversion and small file compaction. The supported design is to transform row-oriented sources into reasonably sized columnar Parquet files with balanced compression and partition layout.