Changes for python binding

Author: siara-cc

Makefile

@@ -16,6 +16,8 @@ test_sqlite_blaster: test_sqlite_blaster.cpp src/*.h
 
 clean:
 	rm test_sqlite_blaster
+        rm *.db
+        rm *.txt
 
 #build/.o: src/imain.cpp src/*.h
 #   $(CXX) $(CXXFLAGS) $(INCLUDES) -c src/imain.cpp -o build/imain.o

README.md

@@ -215,6 +215,7 @@ Valentine's Day,Comedy,Warner Bros.
 - Deletes are not implemented yet.  This library is intended primarily for fast inserts.
 - Support for concurrent inserts not implemented yet.
 - The regular ROWID table of Sqlite is not implemented.
+- Only the equivalent of memcmp is used to index records.  The order in which keys are ordered may not match with official Sqlite lib for non-ASCII char sets.
 - Key lengths are limited depending on page size as shown in the table below.  This is just because the source code does not implement support for longer keys. However, this is considered sufficient for most practical purposes.
 
   | **Page Size** | **Max Key Length** |

src/btree_handler.h

@@ -197,6 +197,8 @@ class btree_handler {
         int search_result = traverse_to_leaf(ctx);
         if (search_result < 0)
             return false;
+        if (in_size_out_val_len != NULL)
+            *in_size_out_val_len = key_at_len;
         if (val != NULL)
             descendant->copy_value(val, in_size_out_val_len);
         return true;

src/lru_cache.h

@@ -49,7 +49,7 @@ class lru_cache {
     size_t disk_to_cache_map_size;
     dbl_lnklst *llarr;
     std::set<int> new_pages;
-    char filename[100];
+    std::string filename;
 #if USE_FOPEN == 1
     FILE *fp;
 #else
@@ -197,15 +197,14 @@ if (page_size == 4096) {
     lru_cache(int pg_size, int cache_size_kb, const char *fname,
             bool (*is_changed)(uint8_t *, int), void (*set_changed)(uint8_t *, int, bool),
             int init_page_count = 0, void *(*alloc_fn)(size_t) = NULL)
-                : is_changed_fn (is_changed), set_changed_fn (set_changed) {
+                : filename (fname), is_changed_fn (is_changed), set_changed_fn (set_changed) {
         if (alloc_fn == NULL)
             alloc_fn = malloc;
         malloc_fn = alloc_fn;
         page_size = pg_size;
         cache_size_in_pages = cache_size_kb * 1024 / page_size;
         cache_occupied_size = 0;
         lnklst_first_entry = lnklst_last_entry = NULL;
-        strcpy(filename, fname);
         page_cache = (uint8_t *) alloc_fn(pg_size * cache_size_in_pages);
         root_block = (uint8_t *) alloc_fn(pg_size);
         llarr = (dbl_lnklst *) alloc_fn(cache_size_in_pages * sizeof(dbl_lnklst));

src/sqlite_index_blaster.h

@@ -148,110 +148,6 @@ class sqlite_index_blaster : public btree_handler<sqlite_index_blaster> {
             return *ptr;
         }
 
-        // Reads and returns big-endian uint16_t
-        // at a given memory location
-        uint16_t read_uint16(const uint8_t *ptr) {
-            return (*ptr << 8) + ptr[1];
-        }
-
-        // Reads and returns big-endian int24_t
-        // at a given memory location
-        int32_t read_int24(const uint8_t *ptr) {
-            uint32_t ret;
-            ret = ((uint32_t)(*ptr & 0x80)) << 24;
-            ret |= ((uint32_t)(*ptr++ & 0x7F)) << 16;
-            ret |= ((uint32_t)*ptr++) << 8;
-            ret += *ptr;
-            return ret;
-        }
-
-        // Reads and returns big-endian uint24_t
-        // at a given memory location
-        uint32_t read_uint24(const uint8_t *ptr) {
-            uint32_t ret;
-            ret = ((uint32_t)*ptr++) << 16;
-            ret += ((uint32_t)*ptr++) << 8;
-            ret += *ptr;
-            return ret;
-        }
-
-        // Reads and returns big-endian uint32_t
-        // at a given memory location
-        uint32_t read_uint32(const uint8_t *ptr) {
-            uint32_t ret;
-            ret = ((uint32_t)*ptr++) << 24;
-            ret += ((uint32_t)*ptr++) << 16;
-            ret += ((uint32_t)*ptr++) << 8;
-            ret += *ptr;
-            return ret;
-        }
-
-        // Reads and returns big-endian int48_t
-        // at a given memory location
-        int64_t read_int48(const uint8_t *ptr) {
-            uint64_t ret;
-            ret = ((uint64_t)(*ptr & 0x80)) << 56;
-            ret |= ((uint64_t)(*ptr++ & 0x7F)) << 48;
-            ret |= ((uint64_t)*ptr++) << 32;
-            ret |= ((uint64_t)*ptr++) << 24;
-            ret |= ((uint64_t)*ptr++) << 16;
-            ret |= ((uint64_t)*ptr++) << 8;
-            ret += *ptr;
-            return ret;
-        }
-
-        // Reads and returns big-endian uint48_t :)
-        // at a given memory location
-        uint64_t read_uint48(const uint8_t *ptr) {
-            uint64_t ret = 0;
-            int len = 6;
-            while (len--)
-                ret += (*ptr++ << (8 * len));
-            return ret;
-        }
-
-        // Reads and returns big-endian uint64_t
-        // at a given memory location
-        uint64_t read_uint64(const uint8_t *ptr) {
-            uint64_t ret = 0;
-            int len = 8;
-            while (len--)
-                ret += (*ptr++ << (8 * len));
-            return ret;
-        }
-
-        // Reads and returns variable integer
-        // from given location as uint16_t
-        // Also returns the length of the varint
-        uint16_t read_vint16(const uint8_t *ptr, int8_t *vlen) {
-            uint16_t ret = 0;
-            int8_t len = 3; // read max 3 bytes
-            do {
-                ret <<= 7;
-                ret += *ptr & 0x7F;
-                len--;
-            } while ((*ptr++ & 0x80) == 0x80 && len);
-            if (vlen)
-                *vlen = 3 - len;
-            return ret;
-        }
-
-        // Reads and returns variable integer
-        // from given location as uint32_t
-        // Also returns the length of the varint
-        uint32_t read_vint32(const uint8_t *ptr, int8_t *vlen) {
-            uint32_t ret = 0;
-            int8_t len = 5; // read max 5 bytes
-            do {
-                ret <<= 7;
-                ret += *ptr & 0x7F;
-                len--;
-            } while ((*ptr++ & 0x80) == 0x80 && len);
-            if (vlen)
-                *vlen = 5 - len;
-            return ret;
-        }
-
         // Returns type of column based on given value and length
         // See https://www.sqlite.org/fileformat.html#record_format
         uint32_t derive_col_type_or_len(int type, const void *val, int len) {
@@ -317,28 +213,6 @@ class sqlite_index_blaster : public btree_handler<sqlite_index_blaster> {
             return len;
         }
 
-        // See .h file for API description
-        uint32_t derive_data_len(uint32_t col_type_or_len) {
-            if (col_type_or_len >= 12) {
-                if (col_type_or_len % 2)
-                    return (col_type_or_len - 13)/2;
-                return (col_type_or_len - 12)/2; 
-            } else if (col_type_or_len < 10)
-                return col_data_lens[col_type_or_len];
-            return 0;
-        }
-
-        // See .h file for API description
-        uint32_t derive_col_type(uint32_t col_type_or_len) {
-            if (col_type_or_len >= 12) {
-                if (col_type_or_len % 2)
-                    return SQLT_TYPE_TEXT;
-                return SQLT_TYPE_BLOB;
-            } else if (col_type_or_len < 10)
-                return col_type_or_len;
-            return 0;
-        }
-
         // Initializes the buffer as a B-Tree Leaf Index
         void init_bt_idx_interior(uint8_t *ptr) {
             ptr[0] = 2; // Interior index b-tree page
@@ -580,10 +454,6 @@ class sqlite_index_blaster : public btree_handler<sqlite_index_blaster> {
                 | ((int64_t)(bytes & 0x7FFFFF) << (52-23) );
         }
 
-        double read_double(const uint8_t *ptr) {
-            return (double) *ptr; // TODO: assuming little endian?
-        }
-
         int64_t cvt_to_int64(const uint8_t *ptr, int type) {
             switch (type) {
                 case SQLT_TYPE_NULL:
@@ -727,6 +597,136 @@ class sqlite_index_blaster : public btree_handler<sqlite_index_blaster> {
             return write_new_rec(-1, 0, col_count, values, value_lens, types, ptr);
         }
 
+        // Reads and returns big-endian uint16_t
+        // at a given memory location
+        uint16_t read_uint16(const uint8_t *ptr) {
+            return (*ptr << 8) + ptr[1];
+        }
+
+        // Reads and returns big-endian int24_t
+        // at a given memory location
+        int32_t read_int24(const uint8_t *ptr) {
+            uint32_t ret;
+            ret = ((uint32_t)(*ptr & 0x80)) << 24;
+            ret |= ((uint32_t)(*ptr++ & 0x7F)) << 16;
+            ret |= ((uint32_t)*ptr++) << 8;
+            ret += *ptr;
+            return ret;
+        }
+
+        // Reads and returns big-endian uint24_t
+        // at a given memory location
+        uint32_t read_uint24(const uint8_t *ptr) {
+            uint32_t ret;
+            ret = ((uint32_t)*ptr++) << 16;
+            ret += ((uint32_t)*ptr++) << 8;
+            ret += *ptr;
+            return ret;
+        }
+
+        // Reads and returns big-endian uint32_t
+        // at a given memory location
+        uint32_t read_uint32(const uint8_t *ptr) {
+            uint32_t ret;
+            ret = ((uint32_t)*ptr++) << 24;
+            ret += ((uint32_t)*ptr++) << 16;
+            ret += ((uint32_t)*ptr++) << 8;
+            ret += *ptr;
+            return ret;
+        }
+
+        // Reads and returns big-endian int48_t
+        // at a given memory location
+        int64_t read_int48(const uint8_t *ptr) {
+            uint64_t ret;
+            ret = ((uint64_t)(*ptr & 0x80)) << 56;
+            ret |= ((uint64_t)(*ptr++ & 0x7F)) << 48;
+            ret |= ((uint64_t)*ptr++) << 32;
+            ret |= ((uint64_t)*ptr++) << 24;
+            ret |= ((uint64_t)*ptr++) << 16;
+            ret |= ((uint64_t)*ptr++) << 8;
+            ret += *ptr;
+            return ret;
+        }
+
+        // Reads and returns big-endian uint48_t :)
+        // at a given memory location
+        uint64_t read_uint48(const uint8_t *ptr) {
+            uint64_t ret = 0;
+            int len = 6;
+            while (len--)
+                ret += (*ptr++ << (8 * len));
+            return ret;
+        }
+
+        // Reads and returns big-endian uint64_t
+        // at a given memory location
+        uint64_t read_uint64(const uint8_t *ptr) {
+            uint64_t ret = 0;
+            int len = 8;
+            while (len--)
+                ret += (*ptr++ << (8 * len));
+            return ret;
+        }
+
+        // Reads and returns variable integer
+        // from given location as uint16_t
+        // Also returns the length of the varint
+        uint16_t read_vint16(const uint8_t *ptr, int8_t *vlen) {
+            uint16_t ret = 0;
+            int8_t len = 3; // read max 3 bytes
+            do {
+                ret <<= 7;
+                ret += *ptr & 0x7F;
+                len--;
+            } while ((*ptr++ & 0x80) == 0x80 && len);
+            if (vlen)
+                *vlen = 3 - len;
+            return ret;
+        }
+
+        // Reads and returns variable integer
+        // from given location as uint32_t
+        // Also returns the length of the varint
+        uint32_t read_vint32(const uint8_t *ptr, int8_t *vlen) {
+            uint32_t ret = 0;
+            int8_t len = 5; // read max 5 bytes
+            do {
+                ret <<= 7;
+                ret += *ptr & 0x7F;
+                len--;
+            } while ((*ptr++ & 0x80) == 0x80 && len);
+            if (vlen)
+                *vlen = 5 - len;
+            return ret;
+        }
+
+        double read_double(const uint8_t *ptr) {
+            return (double) *ptr; // TODO: assuming little endian?
+        }
+
+        // See .h file for API description
+        uint32_t derive_data_len(uint32_t col_type_or_len) {
+            if (col_type_or_len >= 12) {
+                if (col_type_or_len % 2)
+                    return (col_type_or_len - 13)/2;
+                return (col_type_or_len - 12)/2; 
+            } else if (col_type_or_len < 10)
+                return col_data_lens[col_type_or_len];
+            return 0;
+        }
+
+        // See .h file for API description
+        uint32_t derive_col_type(uint32_t col_type_or_len) {
+            if (col_type_or_len >= 12) {
+                if (col_type_or_len % 2)
+                    return SQLT_TYPE_TEXT;
+                return SQLT_TYPE_BLOB;
+            } else if (col_type_or_len < 10)
+                return col_type_or_len;
+            return 0;
+        }
+
         uint8_t *locate_col(int which_col, uint8_t *rec, int& col_type_or_len, int& col_len, int& col_type) {
             int8_t vlen;
             int hdr_len = read_vint32(rec, &vlen);