What problem arises if each query engine is allowed to rewrite the underlying files of a shared table independently?
Select an answer to reveal the explanation.
Short Explanation
If each query engine rewrites the shared table's files on its own, you've got no single authority deciding which files are the table. That's how concurrent uncoordinated writes corrupt the table state. The table format exists so commits are coordinated through one metadata set, not left to luck.
Full Explanation
The correct choice is the one stating that concurrent uncoordinated writes corrupt the table state, because there is no single authority deciding which files constitute the table. Correctness under concurrency depends on a single coordinated view of which files make up the table. If engines rewrite files independently, one engine can delete or replace files another engine believes are current, producing missing rows, duplicated rows, or unreadable state.
The option about queries returning results in an inconsistent column order is incorrect because column ordering is a schema property, not a consequence of uncoordinated writes.
The option about storage costs rising because each engine keeps its own copy of the metadata cache is incorrect because the risk is correctness, not the marginal cost of cached metadata.
The option saying only the engine that wrote last is permitted to read the table afterwards is incorrect because no such read restriction exists; the danger is that all readers see a broken table.
For the exam, the reason engines share a table format is coordinated, atomic commit - not merely a common file layout.