Question 550A BigLake table is updated by two engines, and one external writer ignores transaction metadata, leaving readers with inconsistent snapshots. Which test provides the strongest evidence of a successful correction? Query an approved external table and attempt direct reads of unrelated raw objects under the analyst identity. Query mixed-version parquet fixtures and check expected null/default and type behavior. Execute concurrent append and overwrite tests and compare snapshot identifiers across supported readers. Interrupt a multi-file publication and verify readers remain on a complete previous snapshot. ExplanationCorrect Answer C:Execute concurrent append and overwrite tests and compare snapshot identifiers across supported readers. This exercises the actual failure: Shared files without coordinated table metadata can expose partial or conflicting snapshots under concurrent writes. It is more decisive than checking only job completion or service status. Other Answers A:Query an approved external table and attempt direct reads of unrelated raw objects under the analyst identity. That test may be appropriate to the distinct failure (A company queries Cloud Storage Parquet through BigQuery but worries that giving analysts broad object permissions will expose other raw prefixes.), not the current defect. The evidence needed here is: Execute concurrent append and overwrite tests and compare snapshot identifiers across supported readers. B:Query mixed-version parquet fixtures and check expected null/default and type behavior. This is useful for a different case: A research lake receives parquet files with evolving columns, and batch readers silently interpret missing values as an old schema default. It would not prove this workload met its requirement; the decisive check is: Execute concurrent append and overwrite tests and compare snapshot identifiers across supported readers. D:Interrupt a multi-file publication and verify readers remain on a complete previous snapshot. That test may be appropriate to the distinct failure (A data lake transformation overwrites a curated partition while reporting tools read it, and readers sometimes get mixed old and new files.), not the current defect. The evidence needed here is: Execute concurrent append and overwrite tests and compare snapshot identifiers across supported readers.
Question 551A BigLake table is updated by two engines, and one external writer ignores transaction metadata, leaving readers with inconsistent snapshots. Which release or operational policy best reduces the identified risk? Require snapshot-aware commits and rollback paths for published lake tables. Version lake schemas and block incompatible field-type changes without migration. Limit writes to certified engines and test transactional compatibility before adding connectors. Audit table-source permissions and dataset policies when raw storage prefixes expand. ExplanationCorrect Answer C:Limit writes to certified engines and test transactional compatibility before adding connectors. This is durable because it verifies the condition over future changes: Shared files without coordinated table metadata can expose partial or conflicting snapshots under concurrent writes. Other Answers A:Require snapshot-aware commits and rollback paths for published lake tables. This control protects against the separate condition: A data lake transformation overwrites a curated partition while reporting tools read it, and readers sometimes get mixed old and new files. It leaves the present risk insufficiently controlled; use: Limit writes to certified engines and test transactional compatibility before adding connectors. B:Version lake schemas and block incompatible field-type changes without migration. It is a reasonable safeguard for a different situation: A research lake receives parquet files with evolving columns, and batch readers silently interpret missing values as an old schema default. However, it does not enforce the contract required here. The specific prevention is: Limit writes to certified engines and test transactional compatibility before adding connectors. D:Audit table-source permissions and dataset policies when raw storage prefixes expand. This control protects against the separate condition: A company queries Cloud Storage Parquet through BigQuery but worries that giving analysts broad object permissions will expose other raw prefixes. It leaves the present risk insufficiently controlled; use: Limit writes to certified engines and test transactional compatibility before adding connectors.
Question 552A Cloud Storage lake stores the same object in hot class indefinitely despite monthly scans, and lifecycle changes accidentally break compliance holds. What production change should the data engineer implement to resolve the observed problem? Use appropriately governed external or BigLake table access with narrowly scoped underlying storage permissions. Define lifecycle transitions based on measured reads and retain legal-hold and recovery constraints as independent gates. Trace catalog locations, object existence and consumer permissions before replaying or copying datasets. Register lake assets and ownership in a governed catalog with access policies and searchable business metadata. ExplanationCorrect Answer B:Lower storage class price can be offset by retrieval charges or violate retention if the lifecycle rule deletes protected objects. The remedy operates at the missing layer rather than merely hiding the symptom: Define lifecycle transitions based on measured reads and retain legal-hold and recovery constraints as independent gates. Confirm with: Simulate aged objects with and without holds and verify allowed transition and prohibited deletion. Other Answers A:Use appropriately governed external or BigLake table access with narrowly scoped underlying storage permissions. This would target another data-engineering constraint (A company queries Cloud Storage Parquet through BigQuery but worries that giving analysts broad object permissions will expose other raw prefixes.) rather than the observed failure. Here Lower storage class price can be offset by retrieval charges or violate retention if the lifecycle rule deletes protected objects. The focused solution is: Define lifecycle transitions based on measured reads and retain legal-hold and recovery constraints as independent gates. C:Trace catalog locations, object existence and consumer permissions before replaying or copying datasets. That action fits a different situation: An operations team sees empty lake queries after an object lifecycle move but cannot tell whether catalog pointers, IAM or missing files caused the failure. Its own premise is: A catalog entry can outlive its files or reference a path unreadable to the query identity. In the present case, Lower storage class price can be offset by retrieval charges or violate retention if the lifecycle rule deletes protected objects. The needed correction is: Define lifecycle transitions based on measured reads and retain legal-hold and recovery constraints as independent gates. D:Register lake assets and ownership in a governed catalog with access policies and searchable business metadata. This would target another data-engineering constraint (A lake stores petabytes of Parquet files in Cloud Storage but consumers cannot discover owners or data classifications across teams.) rather than the observed failure. Here Lower storage class price can be offset by retrieval charges or violate retention if the lifecycle rule deletes protected objects. The focused solution is: Define lifecycle transitions based on measured reads and retain legal-hold and recovery constraints as independent gates.
Question 553A Cloud Storage lake stores the same object in hot class indefinitely despite monthly scans, and lifecycle changes accidentally break compliance holds. Which explanation accounts for the specific behavior and why the current approach fails? A catalog entry can outlive its files or reference a path unreadable to the query identity. Object storage alone does not provide discoverability or federated stewardship for a shared lake. Lower storage class price can be offset by retrieval charges or violate retention if the lifecycle rule deletes protected objects. External table metadata and object authorization must be designed together to prevent bypassing curated dataset controls. ExplanationCorrect Answer C:Lower storage class price can be offset by retrieval charges or violate retention if the lifecycle rule deletes protected objects. The scenario therefore calls for this specific correction: Define lifecycle transitions based on measured reads and retain legal-hold and recovery constraints as independent gates. The confirming test is: Simulate aged objects with and without holds and verify allowed transition and prohibited deletion. Other Answers A:A catalog entry can outlive its files or reference a path unreadable to the query identity. The proposed statement applies to An operations team sees empty lake queries after an object lifecycle move but cannot tell whether catalog pointers, IAM or missing files caused the failure. The necessary explanation for the present evidence is instead: Lower storage class price can be offset by retrieval charges or violate retention if the lifecycle rule deletes protected objects. B:Object storage alone does not provide discoverability or federated stewardship for a shared lake. This explains a different case: A lake stores petabytes of Parquet files in Cloud Storage but consumers cannot discover owners or data classifications across teams. It is not the cause in the question: Lower storage class price can be offset by retrieval charges or violate retention if the lifecycle rule deletes protected objects. D:External table metadata and object authorization must be designed together to prevent bypassing curated dataset controls. The proposed statement applies to A company queries Cloud Storage Parquet through BigQuery but worries that giving analysts broad object permissions will expose other raw prefixes. The necessary explanation for the present evidence is instead: Lower storage class price can be offset by retrieval charges or violate retention if the lifecycle rule deletes protected objects.
Question 554A Cloud Storage lake stores the same object in hot class indefinitely despite monthly scans, and lifecycle changes accidentally break compliance holds. Which test provides the strongest evidence of a successful correction? Query an approved external table and attempt direct reads of unrelated raw objects under the analyst identity. Search a catalog entry, follow its object location and validate access as permitted and unpermitted identities. Test a known partition across catalog resolution, object listing and engine read with the actual service account. Simulate aged objects with and without holds and verify allowed transition and prohibited deletion. ExplanationCorrect Answer D:Simulate aged objects with and without holds and verify allowed transition and prohibited deletion. The check tests the corrected behavior, not merely a configuration label, because Lower storage class price can be offset by retrieval charges or violate retention if the lifecycle rule deletes protected objects. Other Answers A:Query an approved external table and attempt direct reads of unrelated raw objects under the analyst identity. This is useful for a different case: A company queries Cloud Storage Parquet through BigQuery but worries that giving analysts broad object permissions will expose other raw prefixes. It would not prove this workload met its requirement; the decisive check is: Simulate aged objects with and without holds and verify allowed transition and prohibited deletion. B:Search a catalog entry, follow its object location and validate access as permitted and unpermitted identities. This test addresses a different case: A lake stores petabytes of Parquet files in Cloud Storage but consumers cannot discover owners or data classifications across teams. It does not validate the scenario in the question, where acceptance requires: Simulate aged objects with and without holds and verify allowed transition and prohibited deletion. C:Test a known partition across catalog resolution, object listing and engine read with the actual service account. That test may be appropriate to the distinct failure (An operations team sees empty lake queries after an object lifecycle move but cannot tell whether catalog pointers, IAM or missing files caused the failure.), not the current defect. The evidence needed here is: Simulate aged objects with and without holds and verify allowed transition and prohibited deletion.
Question 555A Cloud Storage lake stores the same object in hot class indefinitely despite monthly scans, and lifecycle changes accidentally break compliance holds. Which release or operational policy best reduces the identified risk? Monitor broken table locations and sample read-access checks after lifecycle changes. Audit table-source permissions and dataset policies when raw storage prefixes expand. Revisit access profiles, retrieval fees and retention evidence during lifecycle reviews. Require metadata ownership, classification and lifecycle checks for each new lake dataset. ExplanationCorrect Answer C:Revisit access profiles, retrieval fees and retention evidence during lifecycle reviews. It protects the actual requirement instead of only today's fix; the mechanism to control is: Lower storage class price can be offset by retrieval charges or violate retention if the lifecycle rule deletes protected objects. Other Answers A:Monitor broken table locations and sample read-access checks after lifecycle changes. It is a reasonable safeguard for a different situation: An operations team sees empty lake queries after an object lifecycle move but cannot tell whether catalog pointers, IAM or missing files caused the failure. However, it does not enforce the contract required here. The specific prevention is: Revisit access profiles, retrieval fees and retention evidence during lifecycle reviews. B:Audit table-source permissions and dataset policies when raw storage prefixes expand. That policy addresses the mechanism External table metadata and object authorization must be designed together to prevent bypassing curated dataset controls. The present scenario instead needs the ongoing rule: Revisit access profiles, retrieval fees and retention evidence during lifecycle reviews. D:Require metadata ownership, classification and lifecycle checks for each new lake dataset. It is a reasonable safeguard for a different situation: A lake stores petabytes of Parquet files in Cloud Storage but consumers cannot discover owners or data classifications across teams. However, it does not enforce the contract required here. The specific prevention is: Revisit access profiles, retrieval fees and retention evidence during lifecycle reviews.
Question 556A data lake transformation overwrites a curated partition while reporting tools read it, and readers sometimes get mixed old and new files. What production change should the data engineer implement to resolve the observed problem? Publish versioned lake outputs and switch consumers using a supported atomic snapshot or controlled pointer update. Require supported table-format transactions and compatible catalog/snapshot commit protocols for every writer. Enforce schema evolution and schema-on-read compatibility tests using cataloged version metadata. Register lake assets and ownership in a governed catalog with access policies and searchable business metadata. ExplanationCorrect Answer A:Object writes to many files are not automatically an atomic table transaction. The selected action directly addresses the identified defect: Publish versioned lake outputs and switch consumers using a supported atomic snapshot or controlled pointer update. A meaningful acceptance check is: Interrupt a multi-file publication and verify readers remain on a complete previous snapshot. Other Answers B:Require supported table-format transactions and compatible catalog/snapshot commit protocols for every writer. That action fits a different situation: A BigLake table is updated by two engines, and one external writer ignores transaction metadata, leaving readers with inconsistent snapshots. Its own premise is: Shared files without coordinated table metadata can expose partial or conflicting snapshots under concurrent writes. In the present case, Object writes to many files are not automatically an atomic table transaction. The needed correction is: Publish versioned lake outputs and switch consumers using a supported atomic snapshot or controlled pointer update. C:Enforce schema evolution and schema-on-read compatibility tests using cataloged version metadata. This would target another data-engineering constraint (A research lake receives parquet files with evolving columns, and batch readers silently interpret missing values as an old schema default.) rather than the observed failure. Here Object writes to many files are not automatically an atomic table transaction. The focused solution is: Publish versioned lake outputs and switch consumers using a supported atomic snapshot or controlled pointer update. D:Register lake assets and ownership in a governed catalog with access policies and searchable business metadata. Object storage alone does not provide discoverability or federated stewardship for a shared lake. That is relevant to a different case: A lake stores petabytes of Parquet files in Cloud Storage but consumers cannot discover owners or data classifications across teams. It does not establish the control missing here, so choose: Publish versioned lake outputs and switch consumers using a supported atomic snapshot or controlled pointer update.
Question 557A data lake transformation overwrites a curated partition while reporting tools read it, and readers sometimes get mixed old and new files. Which explanation accounts for the specific behavior and why the current approach fails? Object writes to many files are not automatically an atomic table transaction. Object storage alone does not provide discoverability or federated stewardship for a shared lake. Columnar object files can carry differing schemas; readers need explicit compatible projection rules. Shared files without coordinated table metadata can expose partial or conflicting snapshots under concurrent writes. ExplanationCorrect Answer A:Object writes to many files are not automatically an atomic table transaction. This explains the observed behavior rather than a symptom in a different data flow. Apply: Publish versioned lake outputs and switch consumers using a supported atomic snapshot or controlled pointer update. Other Answers B:Object storage alone does not provide discoverability or federated stewardship for a shared lake. That is a valid distinction for another scenario (A lake stores petabytes of Parquet files in Cloud Storage but consumers cannot discover owners or data classifications across teams.), but the described case turns on: Object writes to many files are not automatically an atomic table transaction. C:Columnar object files can carry differing schemas; readers need explicit compatible projection rules. The proposed statement applies to A research lake receives parquet files with evolving columns, and batch readers silently interpret missing values as an old schema default. The necessary explanation for the present evidence is instead: Object writes to many files are not automatically an atomic table transaction. D:Shared files without coordinated table metadata can expose partial or conflicting snapshots under concurrent writes. This explains a different case: A BigLake table is updated by two engines, and one external writer ignores transaction metadata, leaving readers with inconsistent snapshots. It is not the cause in the question: Object writes to many files are not automatically an atomic table transaction.
Question 558A data lake transformation overwrites a curated partition while reporting tools read it, and readers sometimes get mixed old and new files. Which test provides the strongest evidence of a successful correction? Query mixed-version parquet fixtures and check expected null/default and type behavior. Interrupt a multi-file publication and verify readers remain on a complete previous snapshot. Search a catalog entry, follow its object location and validate access as permitted and unpermitted identities. Execute concurrent append and overwrite tests and compare snapshot identifiers across supported readers. ExplanationCorrect Answer B:Interrupt a multi-file publication and verify readers remain on a complete previous snapshot. This validates the intended result after implementing: Publish versioned lake outputs and switch consumers using a supported atomic snapshot or controlled pointer update. The relevant causal principle is: Object writes to many files are not automatically an atomic table transaction. Other Answers A:Query mixed-version parquet fixtures and check expected null/default and type behavior. This test addresses a different case: A research lake receives parquet files with evolving columns, and batch readers silently interpret missing values as an old schema default. It does not validate the scenario in the question, where acceptance requires: Interrupt a multi-file publication and verify readers remain on a complete previous snapshot. C:Search a catalog entry, follow its object location and validate access as permitted and unpermitted identities. This is useful for a different case: A lake stores petabytes of Parquet files in Cloud Storage but consumers cannot discover owners or data classifications across teams. It would not prove this workload met its requirement; the decisive check is: Interrupt a multi-file publication and verify readers remain on a complete previous snapshot. D:Execute concurrent append and overwrite tests and compare snapshot identifiers across supported readers. This test addresses a different case: A BigLake table is updated by two engines, and one external writer ignores transaction metadata, leaving readers with inconsistent snapshots. It does not validate the scenario in the question, where acceptance requires: Interrupt a multi-file publication and verify readers remain on a complete previous snapshot.
Question 559A data lake transformation overwrites a curated partition while reporting tools read it, and readers sometimes get mixed old and new files. Which release or operational policy best reduces the identified risk? Version lake schemas and block incompatible field-type changes without migration. Limit writes to certified engines and test transactional compatibility before adding connectors. Require snapshot-aware commits and rollback paths for published lake tables. Require metadata ownership, classification and lifecycle checks for each new lake dataset. ExplanationCorrect Answer C:Require snapshot-aware commits and rollback paths for published lake tables. The safeguard addresses recurrence of the same root issue: Object writes to many files are not automatically an atomic table transaction. Other Answers A:Version lake schemas and block incompatible field-type changes without migration. That policy addresses the mechanism Columnar object files can carry differing schemas; readers need explicit compatible projection rules. The present scenario instead needs the ongoing rule: Require snapshot-aware commits and rollback paths for published lake tables. B:Limit writes to certified engines and test transactional compatibility before adding connectors. This control protects against the separate condition: A BigLake table is updated by two engines, and one external writer ignores transaction metadata, leaving readers with inconsistent snapshots. It leaves the present risk insufficiently controlled; use: Require snapshot-aware commits and rollback paths for published lake tables. D:Require metadata ownership, classification and lifecycle checks for each new lake dataset. That policy addresses the mechanism Object storage alone does not provide discoverability or federated stewardship for a shared lake. The present scenario instead needs the ongoing rule: Require snapshot-aware commits and rollback paths for published lake tables.
Question 560An operations team sees empty lake queries after an object lifecycle move but cannot tell whether catalog pointers, IAM or missing files caused the failure. What production change should the data engineer implement to resolve the observed problem? Publish versioned lake outputs and switch consumers using a supported atomic snapshot or controlled pointer update. Register lake assets and ownership in a governed catalog with access policies and searchable business metadata. Use appropriately governed external or BigLake table access with narrowly scoped underlying storage permissions. Trace catalog locations, object existence and consumer permissions before replaying or copying datasets. ExplanationCorrect Answer D:Trace catalog locations, object existence and consumer permissions before replaying or copying datasets. This is the appropriate intervention because A catalog entry can outlive its files or reference a path unreadable to the query identity. Validate by performing this targeted check: Test a known partition across catalog resolution, object listing and engine read with the actual service account. Other Answers A:Publish versioned lake outputs and switch consumers using a supported atomic snapshot or controlled pointer update. That action fits a different situation: A data lake transformation overwrites a curated partition while reporting tools read it, and readers sometimes get mixed old and new files. Its own premise is: Object writes to many files are not automatically an atomic table transaction. In the present case, A catalog entry can outlive its files or reference a path unreadable to the query identity. The needed correction is: Trace catalog locations, object existence and consumer permissions before replaying or copying datasets. B:Register lake assets and ownership in a governed catalog with access policies and searchable business metadata. This would target another data-engineering constraint (A lake stores petabytes of Parquet files in Cloud Storage but consumers cannot discover owners or data classifications across teams.) rather than the observed failure. Here A catalog entry can outlive its files or reference a path unreadable to the query identity. The focused solution is: Trace catalog locations, object existence and consumer permissions before replaying or copying datasets. C:Use appropriately governed external or BigLake table access with narrowly scoped underlying storage permissions. External table metadata and object authorization must be designed together to prevent bypassing curated dataset controls. That is relevant to a different case: A company queries Cloud Storage Parquet through BigQuery but worries that giving analysts broad object permissions will expose other raw prefixes. It does not establish the control missing here, so choose: Trace catalog locations, object existence and consumer permissions before replaying or copying datasets.