Database Connectivity

1
// Create connection pool (reuses connections for maximum performance)
2
dhoro pool = db_pool_banao("postgres", {
3
    "host": "localhost",
4
    "port": 5432,
5
    "database": "myapp",
6
    "user": "admin",
7
    "password": "secret"
8
}, 10); // Max 10 connections
9
10
// Get connection from pool (very fast, ~0.1ms)
11
dhoro conn = db_pool_nao(pool);
12
13
// Execute query
14
dhoro users = db_query(conn, "SELECT * FROM users WHERE age > 25");
15
16
// Iterate results
17
ghuriye (dhoro i = 0; i < dorghyo(users["rows"]); i = i + 1) {
18
    dhoro user = users["rows"][i];
19
    dekho("User:", user["name"], "Age:", user["age"]);
20
}
21
22
// Return connection to pool (important! Connection is reused)
23
db_pool_ferot(pool, conn);
24
25
// Close pool when done
26
db_pool_bondho(pool);

1
// Connect to PostgreSQL
2
dhoro conn = db_jukto("postgres", {
3
    "host": "localhost",
4
    "port": 5432,
5
    "database": "myapp",
6
    "user": "postgres",
7
    "password": "password"
8
});
9
10
// Execute SELECT query
11
dhoro result = db_query(conn, "SELECT * FROM users");
12
13
dekho("Total users:", dorghyo(result["rows"]));
14
15
// Iterate through results
16
ghuriye (dhoro i = 0; i < dorghyo(result["rows"]); i = i + 1) {
17
    dhoro user = result["rows"][i];
18
    dekho("User ID:", user["id"], "Name:", user["name"]);
19
}
20
21
// Close connection
22
db_bandho(conn);

1
// BAD - Vulnerable to SQL injection!
2
// dhoro query = "SELECT * FROM users WHERE name = '" + userName + "'";
3
4
// GOOD - SQL injection safe!
5
dhoro result = db_proshno(conn, "SELECT * FROM users WHERE name = $1", ["Rahim"]);
6
7
// Insert with parameters
8
dhoro insertResult = db_proshno(conn,
9
    "INSERT INTO users (name, email, age) VALUES ($1, $2, $3)",
10
    ["Rahim Ahmed", "rahim@example.com", 30]
11
);
12
13
dekho("Rows affected:", insertResult["rows_affected"]);
14
dekho("Last insert ID:", insertResult["last_insert_id"]);

1
// Begin transaction
2
dhoro tx = db_transaction_shuru_postgres(conn);
3
4
chesta {
5
    // Transfer money between accounts (atomic operation)
6
    db_exec_postgres(conn, "UPDATE accounts SET balance = balance - 100 WHERE id = 1");
7
    db_exec_postgres(conn, "UPDATE accounts SET balance = balance + 100 WHERE id = 2");
8
9
    // Commit if all operations succeed
10
    db_commit_postgres(tx);
11
    dekho("Transaction completed successfully!");
12
13
} dhoro_bhul (error) {
14
    // Rollback if any operation fails
15
    db_rollback_postgres(tx);
16
    dekho("Transaction failed and rolled back:", error);
17
}

1
// Connect to MySQL
2
dhoro conn = db_jukto("mysql", {
3
    "host": "localhost",
4
    "port": 3306,
5
    "database": "webapp",
6
    "user": "root",
7
    "password": "password"
8
});
9
10
// Complete CRUD operations
11
// CREATE - Insert new user
12
db_proshno(conn, "INSERT INTO users (name, email) VALUES (?, ?)",
13
    ["Karim", "karim@example.com"]);
14
15
// READ - Query users
16
dhoro users = db_query(conn, "SELECT * FROM users");
17
ghuriye (dhoro i = 0; i < dorghyo(users["rows"]); i = i + 1) {
18
    dekho("User:", users["rows"][i]["name"]);
19
}
20
21
// UPDATE - Update user email
22
db_proshno(conn, "UPDATE users SET email = ? WHERE name = ?",
23
    ["new@example.com", "Karim"]);
24
25
// DELETE - Delete user
26
db_proshno(conn, "DELETE FROM users WHERE name = ?", ["Karim"]);
27
28
db_bandho(conn);

1
// Connect to MongoDB
2
dhoro conn = db_jukto("mongodb", {
3
    "host": "localhost",
4
    "port": 27017,
5
    "database": "mydb"
6
});
7
8
// Find documents matching filter
9
dhoro users = db_khojo_mongodb(conn, "users", {
10
    "age": {"$gt": 25},         // Age greater than 25
11
    "city": "Dhaka"              // City is Dhaka
12
});
13
14
dekho("Found", dorghyo(users["rows"]), "users");
15
16
// Display results
17
ghuriye (dhoro i = 0; i < dorghyo(users["rows"]); i = i + 1) {
18
    dhoro user = users["rows"][i];
19
    dekho("Name:", user["name"], "Age:", user["age"], "City:", user["city"]);
20
}

1
// Insert single document
2
db_dhokao_mongodb(conn, "users", {
3
    "name": "Rahim Ahmed",
4
    "age": 30,
5
    "city": "Dhaka",
6
    "profession": "Engineer",
7
    "skills": ["Python", "Go", "BanglaCode"]
8
});
9
10
dekho("User inserted!");

1
// Update documents
2
dhoro updateResult = db_update_mongodb(conn, "users",
3
    {"city": "Dhaka"},                    // Filter
4
    {"$set": {"country": "Bangladesh"}}   // Update
5
);
6
7
dekho("Updated", updateResult["rows_affected"], "documents");
8
9
// Delete documents
10
dhoro deleteResult = db_mujhe_mongodb(conn, "users", {
11
    "age": {"$lt": 18}  // Delete users under 18
12
});
13
14
dekho("Deleted", deleteResult["rows_affected"], "documents");

1
// Connect to Redis
2
dhoro conn = db_jukto("redis", {
3
    "host": "localhost",
4
    "port": 6379
5
});
6
7
// Set key-value
8
db_set_redis(conn, "user:1", "Rahim Ahmed");
9
10
// Set with TTL (time to live - expires after 1 hour)
11
db_set_redis(conn, "session:abc123", "user_data", 3600);
12
13
// Get value
14
dhoro user = db_get_redis(conn, "user:1");
15
dekho("User:", user);
16
17
// Delete key
18
db_del_redis(conn, "user:1");
19
20
// Set expiration on existing key
21
db_expire_redis(conn, "session:abc123", 1800); // 30 minutes

1
// Redis lists work as queues (FIFO) or stacks (LIFO)
2
3
// Add tasks to queue
4
db_rpush_redis(conn, "tasks:queue", "Process order #123");
5
db_rpush_redis(conn, "tasks:queue", "Send email to user");
6
db_rpush_redis(conn, "tasks:queue", "Generate report");
7
8
// Process tasks from queue
9
dhoro task1 = db_lpop_redis(conn, "tasks:queue");
10
dekho("Processing:", task1); // Output: Process order #123
11
12
dhoro task2 = db_lpop_redis(conn, "tasks:queue");
13
dekho("Processing:", task2); // Output: Send email to user

1
// Store user profile as hash (like a map/object)
2
db_hset_redis(conn, "user:1:profile", "name", "Rahim Ahmed");
3
db_hset_redis(conn, "user:1:profile", "age", "30");
4
db_hset_redis(conn, "user:1:profile", "city", "Dhaka");
5
6
// Get single field
7
dhoro name = db_hget_redis(conn, "user:1:profile", "name");
8
dekho("Name:", name);
9
10
// Get all fields
11
dhoro profile = db_hgetall_redis(conn, "user:1:profile");
12
dekho("Full profile:", profile);

1
// Async database function
2
proyash kaj fetchUsers() {
3
    // Connect async
4
    dhoro conn = opekha db_jukto_async("postgres", {
5
        "host": "localhost",
6
        "database": "myapp"
7
    });
8
9
    // Query async
10
    dhoro users = opekha db_query_async(conn, "SELECT * FROM users");
11
12
    // Close async
13
    opekha db_bandho_async(conn);
14
15
    ferao users;
16
}
17
18
// Call async function
19
dhoro result = opekha fetchUsers();
20
dekho("Fetched", dorghyo(result["rows"]), "users");
21
22
// Multiple concurrent queries
23
proyash kaj fetchMultiple() {
24
    dhoro conn = opekha db_jukto_async("postgres", {...});
25
26
    // Run multiple queries concurrently
27
    dhoro users = opekha db_query_async(conn, "SELECT * FROM users");
28
    dhoro posts = opekha db_query_async(conn, "SELECT * FROM posts");
29
30
    opekha db_bandho_async(conn);
31
32
    ferao {"users": users, "posts": posts};
33
}