Python Capstone: High-Performance In-Memory Key-Value Engine

In Plain English

Assemble all C concepts (pointers, struct memory models, dynamic heap memory with malloc/realloc/free, defensive bounds checking, and string manipulation) into a production-grade in-memory key-value record storage engine.

The Mental Model

"You have progressed from understanding individual transistors and memory cells to designing a complete working micro-database engine."

Deep Dive: How It Works

Dynamic Growth Factor: Doubling capacity (capacity * 2) gives amortized O(1) insertion runtime.

Defensive Reallocation: Storing realloc results in temporary pointers prevents memory leaks if realloc fails.

Clean Teardown: Cascading frees ensure every allocated heap byte is returned to the OS.

Syntax Blueprint

typedef struct {
    DatabaseRecord *records;
    size_t count;
    size_t capacity;
} InMemoryStore;

Struct holding dynamic array pointer, active element count, and total allocated capacity.

Core Rules to Remember

Production Memory Architecture: Dynamically resizes heap capacity when full using realloc.

Safe String Copying: Guarantees null-termination on every key inserted.

Zero Memory Leaks: Fully frees internal array buffer and container struct on shutdown.

Common Beginner Traps & How to Fix Them

Mistake:Directly assigning db->records = realloc(db->records, newSize).

Why it happens: If realloc fails and returns NULL, the original pointer is overwritten and lost, leaking all existing data.

How to fix: Assign to a temporary pointer first (DatabaseRecord *temp = realloc(...)), check for NULL, then assign.

Pro Tip: Always write dedicated constructor (db_create) and destructor (db_free) functions for dynamic struct types.

Live Interactive Example

Hit Run Code to see it live

In-Memory Store Implementation

C11 / GCC 9.2

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <stdbool.h>

typedef struct {
    uint32_t id;
    char key[32];
    double value;
} DatabaseRecord;

typedef struct {
    DatabaseRecord *records;
    size_t count;
    size_t capacity;
} InMemoryStore;

InMemoryStore* db_create(size_t initialCapacity) {
    InMemoryStore *db = (InMemoryStore *)malloc(sizeof(InMemoryStore));
    if (!db) return NULL;
    db->records = (DatabaseRecord *)malloc(initialCapacity * sizeof(DatabaseRecord));
    db->count = 0;
    db->capacity = initialCapacity;
    return db;
}

bool db_insert(InMemoryStore *db, uint32_t id, const char *key, double value) {
    if (!db) return false;
    if (db->count >= db->capacity) {
        size_t newCapacity = db->capacity * 2;
        DatabaseRecord *newRecords = (DatabaseRecord *)realloc(db->records, newCapacity * sizeof(DatabaseRecord));
        if (!newRecords) return false;
        db->records = newRecords;
        db->capacity = newCapacity;
    }
    
    DatabaseRecord *rec = &db->records[db->count];
    rec->id = id;
    strncpy(rec->key, key, sizeof(rec->key) - 1);
    rec->key[sizeof(rec->key) - 1] = '\0';
    rec->value = value;
    db->count++;
    return true;
}

void db_free(InMemoryStore *db) {
    if (db) {
        if (db->records) free(db->records);
        free(db);
    }
}

int main(void) {
    InMemoryStore *db = db_create(2);
    db_insert(db, 1001, "cpu_load", 0.42);
    db_insert(db, 1002, "mem_usage", 68.5);
    
    printf("DB Count: %zu, Capacity: %zu\n", db->count, db->capacity);
    printf("Record 0: %s = %.2f\n", db->records[0].key, db->records[0].value);
    
    db_free(db);
    return 0;
}

Output Console

Click "Run Code" to view the rendered output.

How it works: Database records are stored in dynamically allocated heap memory.

Your Turn: Micro Challenge

No pressure! Edit the starter code below and test your solution with instant feedback.

Micro Exercise

Trigger Dynamic Reallocation with 3rd Record

Insert a 3rd record with id: 1003, key: "disk_io", and value: 12.8.
Print Record 2: "Record 2: %s = %.2f\n" using key and value.
Print "Capstone Memory Engine: DEPLOYED\n".

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <stdbool.h>

typedef struct {
    uint32_t id;
    char key[32];
    double value;
} DatabaseRecord;

typedef struct {
    DatabaseRecord *records;
    size_t count;
    size_t capacity;
} InMemoryStore;

void db_free(InMemoryStore *db) {
    if (db) {
        if (db->records) free(db->records);
        free(db);
    }
}

int main(void) {
    InMemoryStore *db = db_create(2);
    db_insert(db, 1001, "cpu_load", 0.42);
    db_insert(db, 1002, "mem_usage", 68.5);
    
    // Insert 3rd record below and print Record 2 and Capstone status
    
    printf("DB Count: %zu, Capacity: %zu\n", db->count, db->capacity);
    printf("Record 0: %s = %.2f\n", db->records[0].key, db->records[0].value);
    
    db_free(db);
    return 0;
}

Sandbox Output

Click "Run & Check" to test your solution.

Finished reading and practicing?

Mark this lesson as completed to update your course progress.

Common Beginner Traps & How to Fix Them

Mistake:Directly assigning db->records = realloc(db->records, newSize).

Why it happens: If realloc fails and returns NULL, the original pointer is overwritten and lost, leaking all existing data.

How to fix: Assign to a temporary pointer first (DatabaseRecord *temp = realloc(...)), check for NULL, then assign.