+ This project is no longer under active development. You can read more here. But if you'd like to keep learning how to make your own SQLite clone from scratch, or one of many other projects like Docker, Redis, Git or BitTorrent, try CodeCrafters.
+
+
+
+If you use my referral link, I get a commision.
\ No newline at end of file
diff --git a/_parts/part2.md b/_parts/part2.md
index 074b4a8..48d58ab 100644
--- a/_parts/part2.md
+++ b/_parts/part2.md
@@ -61,17 +61,15 @@ Lastly, we pass the prepared statement to `execute_statement`. This function wil
Notice that two of our new functions return enums indicating success or failure:
```c
-enum MetaCommandResult_t {
+typedef enum {
META_COMMAND_SUCCESS,
META_COMMAND_UNRECOGNIZED_COMMAND
-};
-typedef enum MetaCommandResult_t MetaCommandResult;
+} MetaCommandResult;
-enum PrepareResult_t { PREPARE_SUCCESS, PREPARE_UNRECOGNIZED_STATEMENT };
-typedef enum PrepareResult_t PrepareResult;
+typedef enum { PREPARE_SUCCESS, PREPARE_UNRECOGNIZED_STATEMENT } PrepareResult;
```
-"Unrecognized statement"? That seems a bit like an exception. But [exceptions are bad](https://www.youtube.com/watch?v=EVhCUSgNbzo) (and C doesn't even support them), so I'm using enum result codes wherever practical. The C compiler will complain if my switch statement doesn't handle a member of the enum, so we can feel a little more confident we handle every result of a function. Expect more result codes to be added in the future.
+"Unrecognized statement"? That seems a bit like an exception. I prefer not to use exceptions (and C doesn't even support them), so I'm using enum result codes wherever practical. The C compiler will complain if my switch statement doesn't handle a member of the enum, so we can feel a little more confident we handle every result of a function. Expect more result codes to be added in the future.
`do_meta_command` is just a wrapper for existing functionality that leaves room for more commands:
@@ -88,13 +86,11 @@ MetaCommandResult do_meta_command(InputBuffer* input_buffer) {
Our "prepared statement" right now just contains an enum with two possible values. It will contain more data as we allow parameters in statements:
```c
-enum StatementType_t { STATEMENT_INSERT, STATEMENT_SELECT };
-typedef enum StatementType_t StatementType;
+typedef enum { STATEMENT_INSERT, STATEMENT_SELECT } StatementType;
-struct Statement_t {
+typedef struct {
StatementType type;
-};
-typedef struct Statement_t Statement;
+} Statement;
```
`prepare_statement` (our "SQL Compiler") does not understand SQL right now. In fact, it only understands two words:
@@ -153,35 +149,31 @@ The skeleton of our database is taking shape... wouldn't it be nice if it stored
```diff
@@ -10,6 +10,23 @@ struct InputBuffer_t {
- };
- typedef struct InputBuffer_t InputBuffer;
+ } InputBuffer;
-+enum MetaCommandResult_t {
++typedef enum {
+ META_COMMAND_SUCCESS,
+ META_COMMAND_UNRECOGNIZED_COMMAND
-+};
-+typedef enum MetaCommandResult_t MetaCommandResult;
++} MetaCommandResult;
+
-+enum PrepareResult_t { PREPARE_SUCCESS, PREPARE_UNRECOGNIZED_STATEMENT };
-+typedef enum PrepareResult_t PrepareResult;
++typedef enum { PREPARE_SUCCESS, PREPARE_UNRECOGNIZED_STATEMENT } PrepareResult;
+
-+enum StatementType_t { STATEMENT_INSERT, STATEMENT_SELECT };
-+typedef enum StatementType_t StatementType;
++typedef enum { STATEMENT_INSERT, STATEMENT_SELECT } StatementType;
+
-+struct Statement_t {
++typedef struct {
+ StatementType type;
-+};
-+typedef struct Statement_t Statement;
++} Statement;
+
InputBuffer* new_input_buffer() {
InputBuffer* input_buffer = malloc(sizeof(InputBuffer));
input_buffer->buffer = NULL;
-@@ -35,16 +52,66 @@ void read_input(InputBuffer* input_buffer) {
- input_buffer->buffer[bytes_read - 1] = 0;
+@@ -40,17 +57,67 @@ void close_input_buffer(InputBuffer* input_buffer) {
+ free(input_buffer);
}
+MetaCommandResult do_meta_command(InputBuffer* input_buffer) {
+ if (strcmp(input_buffer->buffer, ".exit") == 0) {
++ close_input_buffer(input_buffer);
+ exit(EXIT_SUCCESS);
+ } else {
+ return META_COMMAND_UNRECOGNIZED_COMMAND;
@@ -220,6 +212,7 @@ The skeleton of our database is taking shape... wouldn't it be nice if it stored
read_input(input_buffer);
- if (strcmp(input_buffer->buffer, ".exit") == 0) {
+- close_input_buffer(input_buffer);
- exit(EXIT_SUCCESS);
- } else {
- printf("Unrecognized command '%s'.\n", input_buffer->buffer);
@@ -247,4 +240,4 @@ The skeleton of our database is taking shape... wouldn't it be nice if it stored
+ printf("Executed.\n");
}
}
-```
\ No newline at end of file
+```
diff --git a/_parts/part3.md b/_parts/part3.md
index 86033ae..f2c4a61 100644
--- a/_parts/part3.md
+++ b/_parts/part3.md
@@ -44,20 +44,18 @@ That means we need to upgrade our `prepare_statement` function to parse argument
We store those parsed arguments into a new `Row` data structure inside the statement object:
```diff
-+const uint32_t COLUMN_USERNAME_SIZE = 32;
-+const uint32_t COLUMN_EMAIL_SIZE = 255;
-+struct Row_t {
++#define COLUMN_USERNAME_SIZE 32
++#define COLUMN_EMAIL_SIZE 255
++typedef struct {
+ uint32_t id;
+ char username[COLUMN_USERNAME_SIZE];
+ char email[COLUMN_EMAIL_SIZE];
-+};
-+typedef struct Row_t Row;
++} Row;
+
- struct Statement_t {
+ typedef struct {
StatementType type;
+ Row row_to_insert; // only used by insert statement
- };
- typedef struct Statement_t Statement;
+ } Statement;
```
Now we need to copy that data into some data structure representing the table. SQLite uses a B-tree for fast lookups, inserts and deletes. We'll start with something simpler. Like a B-tree, it will group rows into pages, but instead of arranging those pages as a tree it will arrange them as an array.
@@ -110,15 +108,14 @@ We also need code to convert to and from the compact representation.
Next, a `Table` structure that points to pages of rows and keeps track of how many rows there are:
```diff
+const uint32_t PAGE_SIZE = 4096;
-+const uint32_t TABLE_MAX_PAGES = 100;
++#define TABLE_MAX_PAGES 100
+const uint32_t ROWS_PER_PAGE = PAGE_SIZE / ROW_SIZE;
+const uint32_t TABLE_MAX_ROWS = ROWS_PER_PAGE * TABLE_MAX_PAGES;
+
-+struct Table_t {
-+ void* pages[TABLE_MAX_PAGES];
++typedef struct {
+ uint32_t num_rows;
-+};
-+typedef struct Table_t Table;
++ void* pages[TABLE_MAX_PAGES];
++} Table;
```
I'm making our page size 4 kilobytes because it's the same size as a page used in the virtual memory systems of most computer architectures. This means one page in our database corresponds to one page used by the operating system. The operating system will move pages in and out of memory as whole units instead of breaking them up.
@@ -132,7 +129,7 @@ Speaking of which, here is how we figure out where to read/write in memory for a
+void* row_slot(Table* table, uint32_t row_num) {
+ uint32_t page_num = row_num / ROWS_PER_PAGE;
+ void* page = table->pages[page_num];
-+ if (!page) {
++ if (page == NULL) {
+ // Allocate memory only when we try to access page
+ page = table->pages[page_num] = malloc(PAGE_SIZE);
+ }
@@ -181,15 +178,25 @@ Now we can make `execute_statement` read/write from our table structure:
}
```
-Lastly, we need to initialize the table and handle a few more error cases:
+Lastly, we need to initialize the table, create the respective
+memory release function and handle a few more error cases:
```diff
+ Table* new_table() {
-+ Table* table = malloc(sizeof(Table));
++ Table* table = (Table*)malloc(sizeof(Table));
+ table->num_rows = 0;
-+
++ for (uint32_t i = 0; i < TABLE_MAX_PAGES; i++) {
++ table->pages[i] = NULL;
++ }
+ return table;
+}
++
++void free_table(Table* table) {
++ for (int i = 0; table->pages[i]; i++) {
++ free(table->pages[i]);
++ }
++ free(table);
++}
```
```diff
int main(int argc, char* argv[]) {
@@ -247,43 +254,45 @@ Now would be a great time to write some tests, for a couple reasons:
We'll address those issues in the next part. For now, here's the complete diff from this part:
```diff
- typedef struct InputBuffer_t InputBuffer;
-
-+enum ExecuteResult_t { EXECUTE_SUCCESS, EXECUTE_TABLE_FULL };
-+typedef enum ExecuteResult_t ExecuteResult;
-+
- enum MetaCommandResult_t {
- META_COMMAND_SUCCESS,
- META_COMMAND_UNRECOGNIZED_COMMAND
- };
- typedef enum MetaCommandResult_t MetaCommandResult;
-
--enum PrepareResult_t { PREPARE_SUCCESS, PREPARE_UNRECOGNIZED_STATEMENT };
-+enum PrepareResult_t {
+@@ -2,6 +2,7 @@
+ #include