finished csv2heapfile

Author: Akhtar

csv2heapfile.cc

@@ -6,15 +6,86 @@
 #include "library.h"
 
 int main(int argc, const char * argv[]){
-    if (argc<4){
-        std::cout << "csv2heapfile <csv_file> <heapfile> <page_size>";
-        return -1;
+    if (argc < 4) {
+        std::cout << "USAGE: ./csv2headfile <csv_file> <heapfile> <page_size>";
+        return 1;
     }
-    int size_page,new_page, record_no, page_no;
 
-    std::string filename(argv[1]);
-    std::string heapfile(argv[2]);
-    size_page = std::stoi(argv[3]);
+    int is_output = 1;
+    int size_page, size_record, total_records;
+    Page page;
+
+    //opening a csv file using ifstream
+    std::ifstream csv_file;
+    csv_file.open(argv[1]);
+
+    //if file fails to open, then return an error
+    if (!csv_file){
+        std::cout <<"Is not able to open the file" << argv[1] << " in line 18 \n";
+        return 1;
+    }
+
+    //Initializing the heapfile and page
+    Heapfile *heap = new Heapfile();
+    size_page = atoi(argv[3]);
+    FILE *heap_file  = fopen(argv[2], "w+b");
+    if (!(heap_file)){
+        std::cout << "ERROR: not able to find the file "<<argv[2]<<" in line 32\n";
+        return 1;
+    }
+    size_record = NUM_ATTRIBUTES * ATTRIBUTE_SIZE;
+    init_fixed_len_page(&page, size_page,size_record);
+    init_heapfile(heap, size_page, heap_file);
+
+    //Timing
+    struct timeb t;
+    ftime(&t);
+    long start_time_in_ms = (t.time * 1000) + t.millitm;
+
+    while(csv_file){
+        Record *record;
+        std::string line;
+        int indexSlot;
+
+        csv_file >> line;
+        if (line.size()==0){
+            continue;
+        }
+
+        //remove all commas from the line
+        *record = new Record;
+        line.erase(std::remove(line.begin(), line.end(), ","), line.end());
+
+        fixed_len_read((char*)line.c_str(), size_record, r);
+        indexSlot = add_fixed_len_page(&page, r);
+
+        //IIf the page is full, write to the disk and recalculate the slot index
+        if (indexSlot == -1){
+            PageID id;
+            id = alloc_page(&page, heap, id);
+            write_page(&page, heap,id);
+            init_fixed_len_page(&page, size_page, size_record);
+            indexSlot = add_fixed_len_page(&page,r);
+        }
+
+        write_fixed_len_page(&page, indexSlot, r);
+        total_records=+1;
+    }
 
+    //If there is some record, write it to the last file
+    if (page.used_slot > 0){
+        PageID id = alloc_page(heap);
+        write_page(&page,heap, id);
+    }
+
+    //calculating the end of time
+    ftime(&t);
+    long total_run_time = ((t.time * 1000) + t.millitm) - start_time_in_ms;
+
+    csv_file.close();
+    std::cout << "RUN TIME Total: " << total_run_time << " milliseconds \n";
+    std::cout << "TOTAL Records: " << total_records << "\n";
+
+    return 0;
 
 }

library.cc

@@ -82,4 +82,80 @@ void read_fixed_len_page(Page *page, int slot, Record *r){
  */
 int fixed_len_page_capacity(Page *page){
     return page->page_size/page->slot_size;
+}
+
+/**
+ * Initalize a heapfile to use the file and page size given.
+ */
+void init_heapfile(Heapfile *heapfile, int page_size, FILE *file){
+    heapfile -> page_size = page_size;
+    headfile -> file_ptr = file;
+
+    //We know the first 8 bytes is the offset to the next page
+    int offset_dir = 0;
+    fwrite(&offset_dir, sizeof(int), 1, file);
+
+    // Filling the rest of the directory with emptines
+    int temp = ((page_size - sizeof(int)) / sizeof(DirectoryEntry));
+    for (int i = 1; i <= temp; ++i){
+        fwrite(&i, sizeof(int), 1, file);
+        fwrite(&page_size, sizeof(int),1,file);
+    }
+    fflush(file);
+}
+
+/**
+ * Deserializes `size` bytes from the buffer, `buf`, and
+ * stores the record in `record`.
+ */
+void fixed_len_read(void *buf, int size, Record *record){
+    int i = 0;
+    while(i< size/ATTRIBUTE_SIZE){
+        char *attr = new char(ATTRIBUTE_SIZE+1);
+        strncpy(attr, buf + (i*ATTRIBUTE_SIZE), ATTRIBUTE_SIZE);
+
+        attr[ATTRIBUTE_SIZE] - '\0';
+
+        if (strlen(attr) > 0){
+            record -> push_back(attr);
+        }
+        ++i;
+    }
+}
+
+/**
+ * Write a record into a given slot.
+ */
+void write_fixed_len_page(Page *page, int slot, Record *r){
+    int temp = !r->empty() && page->data->at(slot).empty();
+    if (temp){
+        page->used_slots++;
+    }
+    page->data->at(slot) = *r;
+}
+
+/**
+ * Write a page from memory to disk
+ */
+void write_page(Page *page, Heapfile *heapfile, PageID pid){
+    fseek(heapfile->file_ptr, pid *heapfeal->page_size, SEEK_SET);
+    char *temp = new char[heapfile->page_size];
+    temp[0] = '\0';
+    int i = 0;
+    while(i<fixed_len_page_capacity(page)){
+        fixed_len_write(&(page->data)->at(i), temp);
+        ++i;
+    }
+    fwrite(temp, heapfile->page_size,1 , heapfile->file_ptr);
+    delete buf;
+
+    int dir_no = get_directory_number(pid, heapfile->page_size);
+    go_to_directory_by_directory_number(dir_no, heapfile->file_ptr);
+    if(search_directory(heapfile, pid)){
+        throw;
+    }
+    
+    int space = heapfile->page_size - (page->used_slots * NUM_ATTRIBUTES * ATTRIBUTE_SIZE);
+    fwrite(&space, sizeof(int), 1, heapfile->file_ptr);
+    fflush(heapfile->file_ptr);
 }