Cross-shard queries in HLD - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding Cross-Shard Query Challenges

Which of the following best describes a primary challenge when executing cross-shard queries in a distributed database system?

A Ensuring data consistency and atomicity across multiple shards during query execution

B Reducing the size of individual shards to improve query speed

C Increasing the number of shards to reduce network latency

D Using a single master node to handle all queries

💡 Hint

Think about what happens when data is spread across multiple independent storage units.

Cross-shard queries must coordinate data from multiple shards, which can lead to challenges in maintaining consistency and atomicity.

❓ Architecture

intermediate

Choosing a Cross-Shard Query Coordination Method

Which architecture pattern is commonly used to coordinate cross-shard queries to ensure consistency and minimize latency?

A Using a single shard to store all data to avoid cross-shard queries

B Centralized coordinator that collects partial results from shards and merges them

C Random shard selection to reduce load on any single shard

D Each shard independently returns full query results without coordination

💡 Hint

Consider how partial results from different shards can be combined efficiently.

A centralized coordinator collects partial results from each shard and merges them to produce the final query result, balancing consistency and performance.

❓ scaling

advanced

Scaling Cross-Shard Query Performance

To improve the performance of cross-shard queries in a system with many shards, which approach is most effective?

A Implementing parallel query execution across shards with asynchronous result aggregation

B Reducing the number of shards to minimize network hops

C Increasing the replication factor of each shard to reduce read latency

D Using synchronous blocking calls to each shard sequentially

💡 Hint

Think about how to use concurrency to reduce total query time.

Parallel execution with asynchronous aggregation allows queries to run concurrently on shards, reducing overall latency.

❓ tradeoff

advanced

Tradeoffs in Cross-Shard Query Consistency Models

Which tradeoff is typically encountered when choosing between strong consistency and eventual consistency for cross-shard queries?

A Eventual consistency requires locking all shards, increasing latency

B Strong consistency reduces latency but risks stale data; eventual consistency increases latency but guarantees up-to-date data

C Both models provide the same latency and data freshness guarantees

D Strong consistency increases latency but guarantees up-to-date data; eventual consistency reduces latency but may return stale data

💡 Hint

Consider how data freshness and response time relate in distributed systems.

Strong consistency ensures the latest data but can slow queries due to coordination; eventual consistency is faster but may serve outdated data.

❓ estimation

expert

Estimating Network Overhead in Cross-Shard Queries

A system has 10 shards. Each shard returns 1 MB of data per query. The network bandwidth between coordinator and shards is 100 Mbps. Approximately how long will it take to transfer all shard data to the coordinator if queries are executed in parallel and network bandwidth is fully utilized?

A About 80 seconds

B About 8 seconds

C About 0.8 seconds

D About 0.08 seconds

💡 Hint

Calculate total data size and convert bandwidth to MB/s for transfer time.

Total data is 10 MB. 100 Mbps equals 12.5 MB/s. Transfer time = 10 MB / 12.5 MB/s = 0.8 seconds.

Practice

1. What is the main purpose of cross-shard queries in a distributed database system?

easy

A. To encrypt data within a shard

B. To backup data from one shard to another

C. To split a large shard into smaller shards

D. To retrieve data from multiple shards to answer a single complex request

Solution

1. Step 1: Understand what shards are

   Shards are parts of a database split to store data separately for scalability.

2. Step 2: Identify the role of cross-shard queries

   Cross-shard queries combine data from multiple shards to answer complex requests that need data from more than one shard.

3. Final Answer:

   To retrieve data from multiple shards to answer a single complex request -> Option D

4. Quick Check:

   Cross-shard queries = combine data from shards [OK]

Hint: Cross-shard queries combine data from many shards [OK]

Common Mistakes:

• Confusing cross-shard queries with data backup
• Thinking cross-shard queries split shards
• Assuming cross-shard queries encrypt data

2. Which component is responsible for splitting and merging queries in cross-shard query processing?

easy

A. Coordinator

B. Shard manager

C. Cache server

D. Load balancer

Solution

1. Step 1: Identify query processing roles

   The coordinator handles query distribution and result merging across shards.

2. Step 2: Match roles to components

   Shard manager manages shards but does not split/merge queries; cache server stores data temporarily; load balancer distributes traffic but not queries.

3. Final Answer:

   Coordinator -> Option A

4. Quick Check:

   Coordinator splits and merges queries [OK]

Hint: Coordinator splits and merges cross-shard queries [OK]

Common Mistakes:

• Confusing shard manager with coordinator
• Thinking cache server merges queries
• Assuming load balancer handles query splitting

3. Consider a system with 3 shards. A cross-shard query is sent to all shards in parallel. If each shard takes 100ms, 120ms, and 80ms respectively to respond, what is the total time to get the combined result?

medium

A. 300ms

B. 80ms

C. 120ms

D. 100ms

Solution

1. Step 1: Understand parallel query execution

   Queries run in parallel, so total time is the longest shard response time.

2. Step 2: Identify the longest response time

   Shard times are 100ms, 120ms, and 80ms. The longest is 120ms.

3. Final Answer:

   120ms -> Option C

4. Quick Check:

   Parallel time = max shard time = 120ms [OK]

Hint: Total time = longest shard response in parallel [OK]

Common Mistakes:

• Adding all shard times instead of taking max
• Choosing shortest shard time
• Confusing sequential with parallel execution

4. A cross-shard query coordinator is returning incomplete results. Which of the following is the most likely cause?

medium

A. Coordinator failed to merge all shard responses

B. Shard keys are not evenly distributed

C. Cache server is overloaded

D. Load balancer is routing traffic incorrectly

Solution

1. Step 1: Analyze incomplete results cause

   Incomplete results usually mean some shard data was not included in the final output.

2. Step 2: Identify coordinator role in merging

   The coordinator merges shard responses; failure here causes missing data.

3. Final Answer:

   Coordinator failed to merge all shard responses -> Option A

4. Quick Check:

   Incomplete results = merge failure [OK]

Hint: Incomplete results often mean merge failure by coordinator [OK]

Common Mistakes:

• Blaming shard key distribution for missing data
• Assuming cache overload causes missing data
• Thinking load balancer affects query merging

5. You want to reduce latency of cross-shard queries in a large distributed system. Which combination of strategies is best?

hard

A. Run queries sequentially on each shard and use a load balancer to distribute traffic

B. Use a coordinator to parallelize queries and implement caching of frequent results

C. Increase shard size and avoid caching to reduce complexity

D. Remove the coordinator and let clients query shards directly

Solution

1. Step 1: Identify strategies to reduce latency

   Parallel query execution via coordinator reduces wait time; caching avoids repeated work.

2. Step 2: Evaluate options

   Use a coordinator to parallelize queries and implement caching of frequent results uses both parallelism and caching, best for latency. Others increase complexity or remove coordination, causing delays.

3. Final Answer:

   Use a coordinator to parallelize queries and implement caching of frequent results -> Option B

4. Quick Check:

   Parallel + caching = lower latency [OK]

Hint: Parallel queries plus caching reduce latency best [OK]

Common Mistakes:

• Thinking bigger shards reduce latency
• Running queries sequentially increases latency
• Removing coordinator causes uncoordinated delays