Query Batching - Practice Coding Problems

Query Batching - Problem

JavaScript Hard

In modern web applications, making multiple small database queries can be inefficient due to network latency. Query batching is an optimization technique that combines multiple small queries into a single large query, reducing network overhead and improving performance.

Your task is to implement a QueryBatcher class that intelligently batches queries using a throttling mechanism.

Class Constructor:

queryMultiple: An asynchronous function that accepts an array of string keys and returns a Promise that resolves to an array of values (same length, where each index corresponds to the value for input[i])
t: Throttle time in milliseconds

Method to Implement:

async getValue(key): Accepts a single string key and returns a Promise that resolves to the corresponding value

Batching Rules:

The first call to getValue should immediately trigger queryMultiple with that single key
Subsequent calls within the throttle period t should be batched together
After t milliseconds, all accumulated keys should be sent to queryMultiple
queryMultiple should never be called consecutively within t milliseconds
All keys are guaranteed to be unique

Example Timeline: If throttle time is 400ms, calls at 0ms, 150ms, 300ms would be batched together and sent at 400ms.

Input & Output

example_1.js — Basic Batching

$ Input: const batcher = new QueryBatcher(mockQuery, 400); const result1 = await batcher.getValue('user123'); const result2 = await batcher.getValue('user456');

› Output: First call: immediate query(['user123']) Second call: batched after 400ms with any other pending keys

💡 Note: The first getValue call triggers an immediate query. The second call waits for the throttle period to batch with other potential calls.

example_2.js — Concurrent Calls

$ Input: const [r1, r2, r3] = await Promise.all([ batcher.getValue('A'), batcher.getValue('B'), batcher.getValue('C') ]);

› Output: Single batched query: queryMultiple(['A', 'B', 'C']) All three promises resolve with their respective values

💡 Note: When multiple getValue calls happen simultaneously (within the same event loop tick), they all get batched into a single query call.

example_3.js — Throttling Edge Case

$ Input: await batcher.getValue('first'); // Wait 500ms setTimeout(() => batcher.getValue('second'), 500);

› Output: Immediate query(['first']) at t=0 Immediate query(['second']) at t=500

💡 Note: Since the second call comes after the throttle period has passed, it triggers immediately rather than being batched.

Visualization

Tap to expand

Understanding the Visualization

First Order Arrives

Kitchen immediately starts preparing the first customer's order - no waiting

More Orders Come In

Similar orders within the next few minutes get added to a preparation batch

Batch Preparation

Chef prepares all batched orders together efficiently, then serves each customer

Next Cycle

After completion, the next order again triggers immediate preparation

Key Takeaway

🎯 Key Insight: Throttled batching optimizes network usage while maintaining responsiveness by treating the first request specially and batching subsequent requests within a time window.

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each getValue call is constant time, batching amortizes cost

✓ Linear Growth

Space Complexity

O(k)

Space for k pending promises in current batch

✓ Linear Space

Constraints

1 ≤ throttle time ≤ 10⁴ milliseconds
1 ≤ number of getValue calls ≤ 1000
All keys are unique strings with length 1 ≤ key.length ≤ 100
queryMultiple always resolves (never rejects)
The throttling must be precise - no calls within t milliseconds of each other

Asked in

f Meta 45 G Google 38 a Amazon 32 ⊞ Microsoft 28 N Netflix 22

The optimal solution uses throttled batching with promise coordination. The first getValue call executes immediately for minimal latency, while subsequent calls within the throttle window get batched together for maximum efficiency. This achieves the perfect balance between responsiveness and network optimization using timeout-based batching and proper async/await handling.

Common Approaches

Approach	Time	Space	Notes
✓ No Batching (Individual Queries)	O(1)	O(1)	Call queryMultiple immediately for every getValue request
Optimal Throttled Batching	O(1)	O(k)	Use timeout-based batching with promise resolution tracking

No Batching (Individual Queries) — Algorithm Steps

For each getValue call, immediately call queryMultiple with [key]
Return the first element of the result array
No throttling or batching logic needed

Visualization

Tap to expand

Step-by-Step Walkthrough

First getValue('A')

Immediately calls queryMultiple(['A'])

Second getValue('B')

Immediately calls queryMultiple(['B'])

Third getValue('C')

Immediately calls queryMultiple(['C'])

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>

typedef struct {
    char** keys;
    int key_count;
    char** results;
    int result_count;
} QueryData;

typedef struct {
    void* (*query_multiple)(char**, int);
    int throttle_time;
} QueryBatcher;

// Mock query function
void* mock_query(char** keys, int count) {
    char** results = malloc(count * sizeof(char*));
    for (int i = 0; i < count; i++) {
        results[i] = malloc(50);
        sprintf(results[i], "value_%s", keys[i]);
    }
    return results;
}

QueryBatcher* create_batcher(void* (*qm)(char**, int), int t) {
    QueryBatcher* batcher = malloc(sizeof(QueryBatcher));
    batcher->query_multiple = qm;
    batcher->throttle_time = t;
    return batcher;
}

char* get_value(QueryBatcher* batcher, char* key) {
    // Naive approach: no batching
    char** keys = malloc(sizeof(char*));
    keys[0] = key;
    
    char** results = (char**)batcher->query_multiple(keys, 1);
    char* result = malloc(strlen(results[0]) + 1);
    strcpy(result, results[0]);
    
    free(keys);
    free(results[0]);
    free(results);
    
    return result;
}

int main() {
    QueryBatcher* batcher = create_batcher(mock_query, 400);
    printf("Naive batching test started\n");
    
    char* result = get_value(batcher, "key1");
    printf("Result: %s\n", result);
    
    free(result);
    free(batcher);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(1)

Each getValue call takes constant time to initiate

✓ Linear Growth

Space Complexity

O(1)

No additional storage needed per query

✓ Linear Space

Constraints

1 ≤ throttle time ≤ 10⁴ milliseconds
1 ≤ number of getValue calls ≤ 1000
All keys are unique strings with length 1 ≤ key.length ≤ 100
queryMultiple always resolves (never rejects)
The throttling must be precise - no calls within t milliseconds of each other

89.2K Views

High Frequency

~35 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

No Batching (Individual Queries) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler