Thisis final i hope

Author: MJavaadAkhtar

csv2colstore.cc

@@ -1,12 +1,13 @@
-#include <algorithm>
 #include <fstream>
 #include <iostream>
 #include <sstream>
-#include <stdlib.h>
-#include <string.h>
 #include <sys/timeb.h>
 #include <sys/stat.h>
 #include "library.h"
+#include <algorithm>
+#include <stdlib.h>
+#include <string.h>
+
 
 int main(int argc, char** argv) {
     if (argc < 4) {

csv2heapfile.cc

@@ -1,10 +1,12 @@
+
+#include <string.h>
+#include <sys/timeb.h>
+#include "library.h"
 #include <algorithm>
 #include <stdlib.h>
 #include <iostream>
 #include <fstream>
-#include <string.h>
-#include <sys/timeb.h>
-#include "library.h"
+
 
 int main(int argc, char** argv) {
     if (argc < 4) {
@@ -13,46 +15,47 @@ int main(int argc, char** argv) {
         return 1;
     }
 
-    bool show_output = true;
-    if (argc == 5 && strcmp(argv[4], "--no-output") == 0) {
-        show_output = false;
-    }
+    std::ifstream fileCsv;
+    fileCsv.open(argv[1]);
 
-    // open csv file
-    std::ifstream csv_file;
-    csv_file.open(argv[1]);
-    if (!csv_file) {
+    if (!fileCsv)
+    {
         std::cout << "Error, could not find file " << argv[1] << "\n";
         return 1;
     }
 
+    bool show_output = true;
+    if (argc == 5 && strcmp(argv[4], "--no-output") == 0) {
+        show_output = false;
+    }
+
     // initialize page
     int page_size = atoi(argv[3]);
-    int record_size = NUM_ATTRIBUTES * ATTRIBUTE_SIZE;
+    int record_size = 100 * 10;
 
     Page page;
     init_fixed_len_page(&page, page_size, record_size);
 
     // initialize heapfile
     Heapfile *heap = new Heapfile();
-    FILE* heap_file = fopen(argv[2], "w+b");
-    if (!heap_file) {
+    FILE* fileHeap = fopen(argv[2], "w+b");
+    if (!fileHeap) {
         std::cout << "Error, could not find file " << argv[2] << "\n";
         return 1;
     }
 
-    init_heapfile(heap, page_size, heap_file);
+    init_heapfile(heap, page_size, fileHeap);
 
     // timing and counting stuff
     struct timeb t;
     ftime(&t);
     long start_time_in_ms = (t.time * 1000) + t.millitm;
 
-    int total_records = 0;
-    while (csv_file) {
+    int Tots = 0;
+    while (fileCsv) {
 
         std::string line;
-        csv_file >> line;
+        fileCsv >> line;
 
         if (line.size() == 0) {
             // ignore empty lines
@@ -83,7 +86,7 @@ int main(int argc, char** argv) {
 
         write_fixed_len_page(&page, slot_index, r);
 
-        total_records++;
+        Tots++;
     }
 
     // write last page to file if it has records
@@ -96,11 +99,11 @@ int main(int argc, char** argv) {
     ftime(&t);
     long total_run_time = ((t.time * 1000) + t.millitm) - start_time_in_ms;
 
-    csv_file.close();
+    fileCsv.close();
 
     if (show_output) {
         std::cout << "RUN TIME: " << total_run_time << " milliseconds\n";
-        std::cout << "TOTAL RECORDS: " << total_records << "\n";
+        std::cout << "TOTAL RECORDS: " << Tots << "\n";
     }
     return 0;
 }

delete.cc

@@ -10,23 +10,24 @@ int main(int argc, char** argv) {
         return 1;
     }
 
-    FILE *heapfile = fopen(argv[1], "r+");
-    if (!heapfile) {
-        std::cout << "Error, could not find file " << argv[1] << "\n";
-        return 1;
-    }
-
-    std::string serialized_record_id = argv[2];
-    size_t delimiter_position = serialized_record_id.find(RID_DELIMITER);
-    if (delimiter_position == 0 || delimiter_position == serialized_record_id.length() - 1) {
+    std::string serial_record = argv[2];
+    size_t pos_del = serial_record.find(RID_DELIMITER);
+    if (pos_del == 0 || pos_del == serial_record.length() - 1) {
         std::cout << "Error, record_id must be:\n";
         std::cout << "<page_id>%<slot_number>\n";
         return 1;
     }
 
     RecordID *rid = new RecordID();
-    rid->page_id = atoi(serialized_record_id.substr(0, delimiter_position).c_str());
-    rid->slot = atoi(serialized_record_id.substr(delimiter_position + 1).c_str());
+    rid->page_id = atoi(serial_record.substr(0, pos_del).c_str());
+    rid->slot = atoi(serial_record.substr(pos_del + 1).c_str());
+
+    FILE *heapfile = fopen(argv[1], "r+");
+    if (!heapfile)
+    {
+        std::cout << "Error, could not find file " << argv[1] << "\n";
+        return 1;
+    }
 
     int page_size = atoi(argv[3]);
 

insert.cc

@@ -11,11 +11,6 @@ int main(int argc, char** argv) {
         return 1;
     }
 
-    FILE *heapfile = fopen(argv[1], "r+");
-    if (!heapfile) {
-        std::cout << "Error, could not find file " << argv[1] << "\n";
-        return 1;
-    }
 
     std::ifstream csv_file;
     csv_file.open(argv[2]);
@@ -24,15 +19,21 @@ int main(int argc, char** argv) {
         return 1;
     }
 
+    FILE *heapfile = fopen(argv[1], "r+");
+    if (!heapfile)
+    {
+        std::cout << "Error, could not find file " << argv[1] << "\n";
+        return 1;
+    }
     int page_size = atoi(argv[3]);
 
     Heapfile *heap = new Heapfile();
     heap->page_size = page_size;
     heap->file_ptr = heapfile;
 
-    int record_size = NUM_ATTRIBUTES * ATTRIBUTE_SIZE;
+    int record_size = 100 * 10;
 
-    char *buf;
+    char *buffer;
     Page page;
     init_fixed_len_page(&page, page_size, record_size);
 
@@ -57,11 +58,11 @@ int main(int argc, char** argv) {
 
         if (slot_index == -1) {  // page is full
             int buf_size = page.page_size * record_size;
-            buf = new char[buf_size];
+            buffer = new char[buf_size];
 
             std::vector<Record> *page_data = page.data;
             for (int i = 0; i < fixed_len_page_capacity(&page); i++) {
-                fixed_len_write(&page_data->at(i), buf);
+                fixed_len_write(&page_data->at(i), buffer);
             }
 
             PageID new_pid = alloc_page(heap);
@@ -79,11 +80,11 @@ int main(int argc, char** argv) {
     // write last page to file if it has records
     if (page.used_slots > 0) {
         int buf_size = page.page_size * record_size;
-        buf = new char[buf_size];
+        buffer = new char[buf_size];
 
         std::vector<Record> *page_data = page.data;
         for (int i = 0; i < fixed_len_page_capacity(&page); i++) {
-            fixed_len_write(&page_data->at(i), buf);
+            fixed_len_write(&page_data->at(i), buffer);
         }
 
         PageID new_pid = alloc_page(heap);

library.cc

@@ -22,21 +22,6 @@ void fixed_len_write(Record *record, char *buf) {
     }
 }
 
-void fixed_len_read(char *buf, int size, Record *record) {
-    for (int i = 0; i < size/ATTRIBUTE_SIZE; ++i) {
-        char* attribute = new char[ATTRIBUTE_SIZE + 1];
-        int attribute_index = i * ATTRIBUTE_SIZE;
-        strncpy(attribute, buf + attribute_index, ATTRIBUTE_SIZE);
-
-        // not sure why garbage values are ending up in 'attribute'
-        attribute[ATTRIBUTE_SIZE] = '\0';
-
-        if (strlen(attribute) > 0) {
-            record->push_back(attribute);
-        }
-    }
-}
-
 void init_fixed_len_page(Page *page, int page_size, int slot_size) {
     page->page_size = page_size;
     page->slot_size = slot_size;
@@ -52,6 +37,21 @@ void init_fixed_len_page(Page *page, int page_size, int slot_size) {
     page->data = data;
 }
 
+void read_fixed_len_page(Page *page, int slot, Record *r)
+{
+    *r = page->data->at(slot);
+}
+
+int number_of_pages_per_directory_page(int page_size)
+{
+    return (page_size - sizeof(int)) / sizeof(DirectoryEntry);
+}
+
+int get_directory_number(PageID pid, int page_size)
+{
+    return pid / (number_of_pages_per_directory_page(page_size) + 1);
+}
+
 int fixed_len_page_capacity(Page *page) {
     return page->page_size / page->slot_size;
 }
@@ -72,6 +72,24 @@ int add_fixed_len_page(Page *page, Record *r) {
     return -1;
 }
 
+void fixed_len_read(char *buf, int size, Record *record)
+{
+    for (int i = 0; i < size / ATTRIBUTE_SIZE; ++i)
+    {
+        char *attribute = new char[ATTRIBUTE_SIZE + 1];
+        int attribute_index = i * ATTRIBUTE_SIZE;
+        strncpy(attribute, buf + attribute_index, ATTRIBUTE_SIZE);
+
+        // not sure why garbage values are ending up in 'attribute'
+        attribute[ATTRIBUTE_SIZE] = '\0';
+
+        if (strlen(attribute) > 0)
+        {
+            record->push_back(attribute);
+        }
+    }
+}
+
 void write_fixed_len_page(Page *page, int slot, Record *r) {
     // only increase count if prev is empty and new is not empty
     if (page->data->at(slot).empty() && !r->empty()) {
@@ -80,16 +98,24 @@ void write_fixed_len_page(Page *page, int slot, Record *r) {
     page->data->at(slot) = *r;
 }
 
-void read_fixed_len_page(Page *page, int slot, Record *r) {
-    *r = page->data->at(slot);
-}
+int get_offset_to_last_directory_page(FILE *file)
+{
+    fseek(file, 0, SEEK_SET);
+    int offset_to_next_directory_page = 0;
+    int total_offset_to_last_directory_page = 0;
 
-int number_of_pages_per_directory_page(int page_size) {
-    return (page_size - sizeof(int)) / sizeof(DirectoryEntry);
-}
+    while (offset_to_next_directory_page != 0)
+    {
+        // read offset, will be 0 if current direcory is the last in the file
+        fread(&offset_to_next_directory_page, sizeof(int), 1, file);
 
-int get_directory_number(PageID pid, int page_size) {
-    return pid / (number_of_pages_per_directory_page(page_size) + 1);
+        total_offset_to_last_directory_page += offset_to_next_directory_page;
+
+        // jump to next directory
+        fseek(file, total_offset_to_last_directory_page, SEEK_SET);
+    }
+
+    return total_offset_to_last_directory_page;
 }
 
 /*
@@ -144,23 +170,6 @@ void init_heapfile(Heapfile *heapfile, int page_size, FILE *file) {
     fflush(file);
 }
 
-int get_offset_to_last_directory_page(FILE *file) {
-    fseek(file, 0, SEEK_SET);
-    int offset_to_next_directory_page = 0;
-    int total_offset_to_last_directory_page = 0;
-
-    while (offset_to_next_directory_page != 0) {
-        // read offset, will be 0 if current direcory is the last in the file
-        fread(&offset_to_next_directory_page, sizeof(int), 1, file);
-
-        total_offset_to_last_directory_page += offset_to_next_directory_page;
-
-        // jump to next directory
-        fseek(file, total_offset_to_last_directory_page, SEEK_SET);
-    }
-
-    return total_offset_to_last_directory_page;
-}
 
 PageID alloc_page(Heapfile *heapfile) {
     int offset_to_last_directory = get_offset_to_last_directory_page(heapfile->file_ptr) * heapfile->page_size;

library.h

@@ -33,6 +33,14 @@ typedef struct {
     int page_size;
 } Heapfile;
 
+class RecordIterator
+{
+  public:
+    RecordIterator(Heapfile *heapfile);
+    Record next();
+    bool hasNext();
+};
+
 const int NUM_ATTRIBUTES = 100;
 const int ATTRIBUTE_SIZE = 10;
 
@@ -68,12 +76,6 @@ void write_fixed_len_page(Page *page, int slot, Record *r);
 // Read a record from the page from a given slot.
 void read_fixed_len_page(Page *page, int slot, Record *r);
 
-class RecordIterator {
-    public:
-        RecordIterator(Heapfile *heapfile);
-        Record next();
-        bool hasNext();
-};
 
 // Returns max # of directory entries that can fit into one page
 int number_of_pages_per_directory_page(int page_size);