MongoDB Drivers Interview Questions

// Configure connection pool
MongoClientSettings settings = MongoClientSettings.builder()
    .applyConnectionString(new ConnectionString("mongodb://localhost:27017"))
    .applyToConnectionPoolSettings(builder -> 
        builder.maxSize(100)
              .minSize(10)
              .maxWaitTime(5000, TimeUnit.MILLISECONDS)
              .maxConnectionLifeTime(30, TimeUnit.MINUTES))
    .build();

// Create client with pool
MongoClient client = MongoClients.create(settings);

// Use connection pool
try (MongoDatabase database = client.getDatabase("myapp")) {
    MongoCollection collection = database.getCollection("users");
    // Perform operations
}

// Configure connection pool
const { MongoClient } = require('mongodb');

const options = {
    maxPoolSize: 100,
    minPoolSize: 10,
    maxIdleTimeMS: 30000,
    connectTimeoutMS: 5000,
    socketTimeoutMS: 45000
};

// Create client with pool
const client = new MongoClient('mongodb://localhost:27017', options);

async function run() {
    try {
        await client.connect();
        const db = client.db('myapp');
        const collection = db.collection('users');
        // Perform operations
    } finally {
        await client.close();
    }
}

// Java error handling
try {
    MongoCollection collection = database.getCollection("users");
    collection.insertOne(document);
} catch (MongoWriteException e) {
    if (e.getError().getCode() == 11000) {
        // Handle duplicate key error
    } else {
        throw e;
    }
} catch (MongoTimeoutException e) {
    // Handle timeout
} catch (MongoException e) {
    // Handle other MongoDB errors
}

// Node.js error handling
try {
    await collection.insertOne(document);
} catch (error) {
    if (error.code === 11000) {
        // Handle duplicate key error
    } else if (error.name === 'MongoTimeoutError') {
        // Handle timeout
    } else {
        throw error;
    }
}

// Java retry logic
public  T withRetry(Supplier operation, int maxRetries) {
    int attempts = 0;
    while (attempts < maxRetries) {
        try {
            return operation.get();
        } catch (MongoException e) {
            attempts++;
            if (attempts == maxRetries) {
                throw e;
            }
            // Exponential backoff
            Thread.sleep((long) Math.pow(2, attempts) * 100);
        }
    }
    throw new MongoException("Max retries exceeded");
}

// Node.js retry logic
async function withRetry(operation, maxRetries = 3) {
    let attempts = 0;
    while (attempts < maxRetries) {
        try {
            return await operation();
        } catch (error) {
            attempts++;
            if (attempts === maxRetries) {
                throw error;
            }
            // Exponential backoff
            await new Promise(resolve => 
                setTimeout(resolve, Math.pow(2, attempts) * 100)
            );
        }
    }
}

// Java optimization
MongoClientSettings settings = MongoClientSettings.builder()
    .applyConnectionString(new ConnectionString("mongodb://localhost:27017"))
    .applyToSocketSettings(builder -> 
        builder.connectTimeout(5000, TimeUnit.MILLISECONDS)
               .readTimeout(5000, TimeUnit.MILLISECONDS))
    .applyToServerSettings(builder -> 
        builder.heartbeatFrequency(10000, TimeUnit.MILLISECONDS))
    .applyToClusterSettings(builder -> 
        builder.serverSelectionTimeout(5000, TimeUnit.MILLISECONDS))
    .build();

// Node.js optimization
const options = {
    connectTimeoutMS: 5000,
    socketTimeoutMS: 5000,
    heartbeatFrequencyMS: 10000,
    serverSelectionTimeoutMS: 5000,
    maxPoolSize: 100,
    minPoolSize: 10
};

// Java batch operations
List> operations = new ArrayList<>();
for (Document doc : documents) {
    operations.add(new InsertOneModel<>(doc));
}

BulkWriteResult result = collection.bulkWrite(operations);

// Node.js batch operations
const operations = documents.map(doc => ({
    insertOne: { document: doc }
}));

const result = await collection.bulkWrite(operations);

// Java connection management
public class MongoConnectionManager {
    private static MongoClient client;
    
    public static synchronized MongoClient getClient() {
        if (client == null) {
            MongoClientSettings settings = MongoClientSettings.builder()
                .applyConnectionString(new ConnectionString("mongodb://localhost:27017"))
                .build();
            client = MongoClients.create(settings);
        }
        return client;
    }
    
    public static void closeClient() {
        if (client != null) {
            client.close();
            client = null;
        }
    }
}

// Node.js connection management
class MongoConnectionManager {
    static client = null;
    
    static async getClient() {
        if (!this.client) {
            this.client = new MongoClient('mongodb://localhost:27017');
            await this.client.connect();
        }
        return this.client;
    }
    
    static async closeClient() {
        if (this.client) {
            await this.client.close();
            this.client = null;
        }
    }
}

// Java query optimization
public class MongoQueryOptimizer {
    public static FindIterable optimizeQuery(
        MongoCollection collection,
        Document query,
        Document projection
    ) {
        return collection.find(query)
            .projection(projection)
            .hint("index_name")
            .batchSize(1000)
            .maxTime(5000, TimeUnit.MILLISECONDS);
    }
}

// Node.js query optimization
class MongoQueryOptimizer {
    static optimizeQuery(collection, query, projection) {
        return collection.find(query)
            .project(projection)
            .hint('index_name')
            .batchSize(1000)
            .maxTimeMS(5000);
    }
}