Merge branch 'part3-fixes' into walkthrough-revisions-fixes

Author: kodemartin

_parts/part3.md

@@ -44,8 +44,8 @@ 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;
++#define COLUMN_USERNAME_SIZE = 32;
++#define COLUMN_EMAIL_SIZE = 255;
 +struct Row_t {
 +  uint32_t id;
 +  char username[COLUMN_USERNAME_SIZE];
@@ -115,8 +115,8 @@ Next, a `Table` structure that points to pages of rows and keeps track of how ma
 +const uint32_t TABLE_MAX_ROWS = ROWS_PER_PAGE * TABLE_MAX_PAGES;
 +
 +struct Table_t {
-+  void* pages[TABLE_MAX_PAGES];
 +  uint32_t num_rows;
++  void** pages;
 +};
 +typedef struct Table_t Table;
 ```
@@ -132,7 +132,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 +181,26 @@ 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 = calloc(sizeof(Table));
++  Table* table = malloc(sizeof(Table));
 +  table->num_rows = 0;
-+
++  // Allocate space for the pointers to the pages
++  // and initialize them to NULL
++  table->pages = calloc(TABLE_MAX_PAGES, sizeof(void *));
 +  return table;
 +}
++
++void free_table(Table* table) {
++    for (int i = 0; table->pages[i]; i++) {
++	free(table->pages[i]);
++    }
++    free(table->pages);
++    free(table);
++}
 ```
 ```diff
  int main(int argc, char* argv[]) {
@@ -247,43 +258,52 @@ 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
+@@ -2,6 +2,7 @@
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <string.h>
++#include <stdint.h>
+
+ struct InputBuffer_t {
+   char* buffer;
+@@ -10,6 +11,106 @@ struct InputBuffer_t {
+ };
  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 MetaCommandResult_t {
++  META_COMMAND_SUCCESS,
++  META_COMMAND_UNRECOGNIZED_COMMAND
++};
++typedef enum MetaCommandResult_t MetaCommandResult;
++
 +enum PrepareResult_t {
 +  PREPARE_SUCCESS,
 +  PREPARE_SYNTAX_ERROR,
 +  PREPARE_UNRECOGNIZED_STATEMENT
-+};
- typedef enum PrepareResult_t PrepareResult;
- 
- enum StatementType_t { STATEMENT_INSERT, STATEMENT_SELECT };
- typedef enum StatementType_t StatementType;
- 
-+const uint32_t COLUMN_USERNAME_SIZE = 32;
-+const uint32_t COLUMN_EMAIL_SIZE = 255;
++ };
++typedef enum PrepareResult_t PrepareResult;
++
++enum StatementType_t { STATEMENT_INSERT, STATEMENT_SELECT };
++typedef enum StatementType_t StatementType;
++
++#define COLUMN_USERNAME_SIZE 32
++#define COLUMN_EMAIL_SIZE 255
 +struct Row_t {
-+  uint32_t id;
-+  char username[COLUMN_USERNAME_SIZE];
-+  char email[COLUMN_EMAIL_SIZE];
++    uint32_t id;
++    char username[COLUMN_USERNAME_SIZE];
++    char email[COLUMN_EMAIL_SIZE];
 +};
 +typedef struct Row_t Row;
 +
- struct Statement_t {
-   StatementType type;
-+  Row row_to_insert;  // only used by insert statement
- };
- typedef struct Statement_t Statement;
- 
++struct Statement_t {
++  StatementType type;
++  Row row_to_insert; //only used by insert statement
++};
++typedef struct Statement_t Statement;
++
 +#define size_of_attribute(Struct, Attribute) sizeof(((Struct*)0)->Attribute)
 +
 +const uint32_t ID_SIZE = size_of_attribute(Row, id);
@@ -300,130 +320,168 @@ We'll address those issues in the next part. For now, here's the complete diff f
 +const uint32_t TABLE_MAX_ROWS = ROWS_PER_PAGE * TABLE_MAX_PAGES;
 +
 +struct Table_t {
-+  void* pages[TABLE_MAX_PAGES];
-+  uint32_t num_rows;
++    uint32_t num_rows;
++    void** pages;
 +};
 +typedef struct Table_t Table;
 +
 +void print_row(Row* row) {
-+  printf("(%d, %s, %s)\n", row->id, row->username, row->email);
++    printf("(%d, %s, %s)\n", row->id, row->username, row->email);
 +}
 +
 +void serialize_row(Row* source, void* destination) {
-+  memcpy(destination + ID_OFFSET, &(source->id), ID_SIZE);
-+  memcpy(destination + USERNAME_OFFSET, &(source->username), USERNAME_SIZE);
-+  memcpy(destination + EMAIL_OFFSET, &(source->email), EMAIL_SIZE);
++    memcpy(destination + ID_OFFSET, &(source->id), ID_SIZE);
++    memcpy(destination + USERNAME_OFFSET, &(source->username), USERNAME_SIZE);
++    memcpy(destination + EMAIL_OFFSET, &(source->email), EMAIL_SIZE);
 +}
 +
-+void deserialize_row(void* source, Row* destination) {
-+  memcpy(&(destination->id), source + ID_OFFSET, ID_SIZE);
-+  memcpy(&(destination->username), source + USERNAME_OFFSET, USERNAME_SIZE);
-+  memcpy(&(destination->email), source + EMAIL_OFFSET, EMAIL_SIZE);
++void deserialize_row(void *source, Row* destination) {
++    memcpy(&(destination->id), source + ID_OFFSET, ID_SIZE);
++    memcpy(&(destination->username), source + USERNAME_OFFSET, USERNAME_SIZE);
++    memcpy(&(destination->email), source + EMAIL_OFFSET, EMAIL_SIZE);
 +}
 +
 +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) {
-+    // Allocate memory only when we try to access page
-+    page = table->pages[page_num] = malloc(PAGE_SIZE);
-+  }
-+  uint32_t row_offset = row_num % ROWS_PER_PAGE;
-+  uint32_t byte_offset = row_offset * ROW_SIZE;
-+  return page + byte_offset;
++    uint32_t page_num = row_num / ROWS_PER_PAGE;
++    void *page = table->pages[page_num];
++    if (page == NULL) {
++	// Allocate memory only when we try to access page
++	page = table->pages[page_num] = malloc(PAGE_SIZE);
++    }
++    uint32_t row_offset = row_num % ROWS_PER_PAGE;
++    uint32_t byte_offset = row_offset * ROW_SIZE;
++    return page + byte_offset;
 +}
 +
 +Table* new_table() {
-+  Table* table = calloc(sizeof(Table));
-+  table->num_rows = 0;
++    Table* table = malloc(sizeof(Table));
++    table->num_rows = 0;
++    // Allocate space for the pointers to the pages
++    // and initialize them to NULL
++    table->pages = calloc(TABLE_MAX_PAGES, sizeof(void *));
++    return table;
++}
 +
-+  return table;
++void free_table(Table* table) {
++    for (int i = 0; table->pages[i]; i++) {
++	free(table->pages[i]);
++    }
++    free(table->pages);
++    free(table);
 +}
 +
  InputBuffer* new_input_buffer() {
    InputBuffer* input_buffer = malloc(sizeof(InputBuffer));
    input_buffer->buffer = NULL;
-@@ -64,6 +137,12 @@ PrepareResult prepare_statement(InputBuffer* input_buffer,
-                                 Statement* statement) {
-   if (strncmp(input_buffer->buffer, "insert", 6) == 0) {
-     statement->type = STATEMENT_INSERT;
+@@ -40,17 +141,105 @@ void close_input_buffer(InputBuffer* input_buffer) {
+     free(input_buffer);
+ }
+
++MetaCommandResult do_meta_command(InputBuffer* input_buffer, Table *table) {
++  if (strcmp(input_buffer->buffer, ".exit") == 0) {
++    close_input_buffer(input_buffer);
++    free_table(table);
++    exit(EXIT_SUCCESS);
++  } else {
++    return META_COMMAND_UNRECOGNIZED_COMMAND;
++  }
++}
++
++PrepareResult prepare_statement(InputBuffer* input_buffer,
++                                Statement* statement) {
++  if (strncmp(input_buffer->buffer, "insert", 6) == 0) {
++    statement->type = STATEMENT_INSERT;
 +    int args_assigned = sscanf(
-+        input_buffer->buffer, "insert %d %s %s", &(statement->row_to_insert.id),
-+        statement->row_to_insert.username, statement->row_to_insert.email);
++	input_buffer->buffer, "insert %d %s %s", &(statement->row_to_insert.id),
++	statement->row_to_insert.username, statement->row_to_insert.email
++	);
 +    if (args_assigned < 3) {
-+      return PREPARE_SYNTAX_ERROR;
++	return PREPARE_SYNTAX_ERROR;
 +    }
-     return PREPARE_SUCCESS;
-   }
-   if (strcmp(input_buffer->buffer, "select") == 0) {
-@@ -74,18 +153,39 @@ PrepareResult prepare_statement(InputBuffer* input_buffer,
-   return PREPARE_UNRECOGNIZED_STATEMENT;
- }
- 
--void execute_statement(Statement* statement) {
-+ExecuteResult execute_insert(Statement* statement, Table* table) {
-+  if (table->num_rows >= TABLE_MAX_ROWS) {
-+    return EXECUTE_TABLE_FULL;
++    return PREPARE_SUCCESS;
++  }
++  if (strcmp(input_buffer->buffer, "select") == 0) {
++    statement->type = STATEMENT_SELECT;
++    return PREPARE_SUCCESS;
 +  }
 +
-+  Row* row_to_insert = &(statement->row_to_insert);
++  return PREPARE_UNRECOGNIZED_STATEMENT;
++}
 +
-+  serialize_row(row_to_insert, row_slot(table, table->num_rows));
-+  table->num_rows += 1;
++ExecuteResult execute_insert(Statement* statement, Table* table) {
++    if (table->num_rows >= TABLE_MAX_ROWS) {
++	return EXECUTE_TABLE_FULL;
++    }
 +
-+  return EXECUTE_SUCCESS;
++    Row* row_to_insert = &(statement->row_to_insert);
++
++    serialize_row(row_to_insert, row_slot(table, table->num_rows));
++    table->num_rows += 1;
++
++    return EXECUTE_SUCCESS;
 +}
 +
 +ExecuteResult execute_select(Statement* statement, Table* table) {
-+  Row row;
-+  for (uint32_t i = 0; i < table->num_rows; i++) {
-+    deserialize_row(row_slot(table, i), &row);
-+    print_row(&row);
++    Row row;
++    for (uint32_t i = 0; i < table->num_rows; i++) {
++	deserialize_row(row_slot(table, i), &row);
++	print_row(&row);
++    }
++    return EXECUTE_SUCCESS;
++}
++
++ExecuteResult execute_statement(Statement* statement, Table *table) {
++  switch (statement->type) {
++    case (STATEMENT_INSERT):
++       	return execute_insert(statement, table);
++    case (STATEMENT_SELECT):
++	return execute_select(statement, table);
 +  }
-+  return EXECUTE_SUCCESS;
 +}
 +
-+ExecuteResult execute_statement(Statement* statement, Table* table) {
-   switch (statement->type) {
-     case (STATEMENT_INSERT):
--      printf("This is where we would do an insert.\n");
--      break;
-+      return execute_insert(statement, table);
-     case (STATEMENT_SELECT):
--      printf("This is where we would do a select.\n");
--      break;
-+      return execute_select(statement, table);
-   }
- }
- 
  int main(int argc, char* argv[]) {
 +  Table* table = new_table();
    InputBuffer* input_buffer = new_input_buffer();
    while (true) {
      print_prompt();
-@@ -105,13 +205,22 @@ int main(int argc, char* argv[]) {
-     switch (prepare_statement(input_buffer, &statement)) {
-       case (PREPARE_SUCCESS):
-         break;
+     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);
++    if (input_buffer->buffer[0] == '.') {
++      switch (do_meta_command(input_buffer, table)) {
++        case (META_COMMAND_SUCCESS):
++          continue;
++        case (META_COMMAND_UNRECOGNIZED_COMMAND):
++          printf("Unrecognized command '%s'\n", input_buffer->buffer);
++          continue;
++      }
++    }
++
++    Statement statement;
++    switch (prepare_statement(input_buffer, &statement)) {
++      case (PREPARE_SUCCESS):
++        break;
 +      case (PREPARE_SYNTAX_ERROR):
-+        printf("Syntax error. Could not parse statement.\n");
++	printf("Syntax error. Could not parse statement.\n");
++	continue;
++      case (PREPARE_UNRECOGNIZED_STATEMENT):
++        printf("Unrecognized keyword at start of '%s'.\n",
++               input_buffer->buffer);
 +        continue;
-       case (PREPARE_UNRECOGNIZED_STATEMENT):
-         printf("Unrecognized keyword at start of '%s'.\n",
-                input_buffer->buffer);
-         continue;
-     }
- 
--    execute_statement(&statement);
--    printf("Executed.\n");
-+    switch (execute_statement(&statement, table)) {
-+      case (EXECUTE_SUCCESS):
-+        printf("Executed.\n");
-+        break;
-+      case (EXECUTE_TABLE_FULL):
-+        printf("Error: Table full.\n");
-+        break;
 +    }
++
++    switch (execute_statement(&statement, table)) {
++	case (EXECUTE_SUCCESS):
++	    printf("Executed.\n");
++	    break;
++	case (EXECUTE_TABLE_FULL):
++	    printf("Error: Table full.\n");
++	    break;
+     }
    }
  }
 ```