Added some file

Author: MJavaadAkhtar

Makefile

@@ -0,0 +1,16 @@
+# Makefile
+CC = g++ 
+
+all: write_fixed_len_pages read_fixed_len_page
+
+library.o: library.cc library.h
+	$(CC) -o $@ -c $<
+
+write_fixed_len_pages: write_fixed_len_pages.cc library.o
+	$(CC) -o $@ $< library.o
+
+read_fixed_len_page: read_fixed_len_page.cc library.o
+	$(CC) -o $@ $< library.o
+
+clean :$
+	\rm -fr write_fixed_len_pages read_fixed_len_page *.o

csv2heapfile.cc

@@ -0,0 +1,20 @@
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <sys/timeb.h>
+#include <cstring>
+#include "library.h"
+
+int main(int argc, const char * argv[]){
+    if (argc<4){
+        std::cout << "csv2heapfile <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]);
+    
+
+}

library.cc

@@ -0,0 +1,85 @@
+#include <algorithm>
+#include <stdint.h>
+
+#include "library.h"
+#include <assert.h>
+#include <stdlib.h>
+
+#include <iostream>
+
+#include <vector>
+#include "string.h"
+
+/**
+ * Compute the number of bytes required to serialize record
+ */
+int fixed_len_sizeof(Record *record){
+    int length = 0;
+    for (Record::iterator t = record->begin(); t!=record->end(); ++t){
+        length += strlen(*t);
+    }
+    return length;
+}
+/**
+ * Serialize the record to a byte array to be stored in buf.
+ */
+void fixed_len_write(Record *record, void *buf){
+    for (int i=0;i<record->size(); i++){
+        int len_str = std::strlen(record->at(i));
+        int pos = (len_str * i);
+        std::memcpy((char *) buf + pos, record->at(i), len_str);
+    }
+}
+
+/**
+ * Initializes a page using the given slot size
+ */
+void init_fixed_len_page(Page *page, int page_size, int slot_size){
+    int slot = page_size/slot_size;
+
+    page->slot_size = slot_size;
+    page->page_size = page_size;
+    page->slot_used = 0;
+    std::vector<Record> *data = new std::vector<Record>();
+
+    for (int i=0; i<slot; ++i){
+        Record *new_rec = new Record();
+        data->push_back(*new_rec);
+        delete new_rec;
+    }
+    page->data = data;
+}
+
+/**
+ * Add a record to the page
+ * Returns:
+ *   record slot offset if successful,
+ *   -1 if unsuccessful (page full)
+ */
+int add_fixed_len_page(Page *page, Record *r){
+    int slot = 0;
+    std::vector<Record> records = *(page->data);
+    for (std::vector<Record>::iterator it = records.begin(); it != records.end(); ++it)
+    {
+        if (it->empty())
+        {
+            return slot;
+        }
+        slot++;
+    }
+    return -1;
+}
+
+/**
+ * Read a record from the page from a given slot.
+ */
+void read_fixed_len_page(Page *page, int slot, Record *r){
+    *r = page->data->at(slot);
+}
+
+/**
+ * Calculates the maximal number of records that fit in a page
+ */
+int fixed_len_page_capacity(Page *page){
+    return page->page_size/page->slot_size;
+}

library.h

@@ -5,9 +5,11 @@ typedef const char* V;
 typedef std::vector<V> Record;
 
 typedef struct {
-    void *data;
+    std::vector<Record> *data;
     int page_size;
     int slot_size;
+    int slot_used;
+    
 } Page;
 
 //The Heap File
@@ -30,7 +32,7 @@ class RecordIterator {
     RecordIterator(Heapfile *heapfile);
     Record next();
     bool hasNext();
-}
+};
 
 /**
  * Initalize a heapfile to use the file and page size given.

read_fixed_len_page.cc

@@ -0,0 +1,63 @@
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <istream>
+#include <sys/timeb.h>
+#include "library.h"
+#include <string>
+
+int main(int argc, const char * argv[]){
+    if (argc<3){
+        std::cout << "USAGE: read_fixed_len_page <page_file> <page_size>";
+        return 1;
+    }
+    int record_no, size_page, page_no;
+
+    std::string filename(argv[1]);
+    size_page = std::stoi(argv[2]);
+
+    // start timer
+    struct timeb t;
+    ftime(&t);
+    unsigned long start_ms = t.time * 1000 + t.millitm;
+
+    std::ifstream filePage;
+    filePage.open(filename, std::ios::in|std::ios::binary);
+
+    FILE * file = fopen("tuples2.csv", "w");
+
+    while(!filePage.eof()){
+        Page page;
+
+        init_fixed_len_page(&page, size_page, 1000);
+
+        filePage.read((char *) page.data, size_page);
+
+        int i=0;
+        while(i!=fixed_len_page_capacity(&page)){
+            Record record;
+            read_fixed_len_page(&page, i, &record);
+            unsigned int j=0;
+            while(j != record.size()){
+                std::cout << record.at(j);
+                if (j!=record.size() - 1){
+                    std::cout << ",";
+                }
+                j++;
+            }
+            fputs("\n", file);
+            record_no++;
+        }
+        page_no++;
+    }
+    fclose(file);
+    filePage.close();
+    ftime(&t);
+    unsigned long stop_ms = t.time * 1000 + t.millitm;
+
+    std::cout << "Number of Records: " << record_no << "\n";
+    std::cout << "Number of Pages: " << page_no << "\n";
+    std::cout << "Time: " << stop_ms - start_ms << " milliseconds\n";
+
+    return 0;
+}

write_fixed_len_pages.cc

@@ -2,11 +2,13 @@
 #include <fstream>
 #include <sys/timeb.h>
 #include <iostream>
+#include <cstring>
 #include "library.h" 
+#include <sstream>
 
 int main(int argc, const char *argv[]) {
     if (argc < 4){
-        std::cout << "Error Usage. USAGE: ./write_fixed_len_pages <csv_file> <page_file> <page_size>"
+        std::cout << "Error Usage. USAGE: ./write_fixed_len_pages <csv_file> <page_file> <page_size>";
         return 1;
     }
     // Initializing variables
@@ -22,7 +24,7 @@ int main(int argc, const char *argv[]) {
     int pageSize = std::stoi(argv[3]);
 
 
-    FilePage.open(pageFilename, std::ios::binary | std::ios:out);
+    FilePage.open(pageFilename, std::ios::binary | std::ios::out);
     std::ifstream csv_file(file_csv);
 
     int new_page_required = 1;
@@ -35,8 +37,8 @@ int main(int argc, const char *argv[]) {
         Record record;
         std::stringstream linestr(l);
         std::string cell;
-        while(std::getline(linestr, cell, ','){
-            char *temp = (cahr *)malloc(11);
+        while(std::getline(linestr, cell, ',')){
+            char *temp = (char *)malloc(11);
             std::strncpy(temp, cell.c_str(), 11);
             record.push_back(temp);
         }
@@ -51,8 +53,25 @@ int main(int argc, const char *argv[]) {
             FilePage.write((const char *) page.data, page.page_size);
             init_fixed_len_page(&page, pageSize, fixed_len_sizeof(&record));
             add_fixed_len_page(&page,&record);
+            new_page_required = 0;
+            Page_no ++;
         }
     }
 
+    if (!new_page_required){
+        FilePage.write((const char *) page.data, page.page_size);
+    }
+
+    FilePage.close();
+
+    ftime(&t);
+    unsigned long stop_ms = t.time * 1000 + t.millitm;
+
+    std::cout << "Number of record are : " << record_no << "\n";
+    std::cout << " Number of page are : " << Page_no << "\n";
+    std::cout << "Time: " << stop_ms - start_ms << " milliseconds\n";
+
+    return 0;
+
 
 }