feat(remove): adding ability to remove key

README.md

@@ -6,6 +6,7 @@
 > Fast document store using B+ Tree for fields. Adapters support for In-Memory and FileSystem 
 
 Complexity : `O(log(n))` - Help welcome to pass it `O(n)`.  
+State : NOT FOR PRODUCTION (see remaining TODO / FIXME / ISSUES).
 
 This library's goal is to provide a way to quickly store document-based data in-memory or on the filesystem.  
 It uses a field-specific indexing system relaying on B+Tree structure.  

docs/api.md

@@ -7,6 +7,7 @@ const tree = new SBTree([props]);
 - Constructor options :
   - `adapter` Adapter - (def: MemoryAdapter) : Allow to specific another adapter to use
   - `order` Number - (def: 511) : Primordial for the performance, the closest to L1 the better. Chose below 2^n. 
+  - `fillFactor` Float - (def: 0.5) : Used for balancing the tree. Should not be less than 0.5 (50%). 
   - `verbose` Bool - (def: false)
   - `uniques` Array - (def: []) - Allow to set some field unique by adding them to this array
   - `exclude` Array - (def: []) - Allow to exclude from indexing some field (important if you expect field value to be huge or nested).

index.js

@@ -1,3 +1,4 @@
 const SBTree = require('./src/types/SBTree/SBTree');
 const adapters = require('./src/adapters/index');
+const utils = require('./src/utils/index');
 module.exports = {SBTree, adapters};

package.json

@@ -4,7 +4,7 @@
   "description": "Optimised document store using B+ Tree for fields. Adapters support for In-Memory and FileSystem",
   "main": "index.js",
   "scripts": {
-    "test": "mocha test/ --recursive",
+    "test": "mocha test/ --recursive ",
     "benchmark": "mocha test/z_benchmark --recursive"
   },
   "engines": {

src/adapters/FsAdapter/FsAdapter.js

@@ -1,36 +1,46 @@
 const {FSLock} = require('fslockjs');
 const EventEmitter = require('events');
 const defaultProps = {
-  options: {
     path: '.db',
     //TODO : Ideally, when false, we keep a set of deferred job that we execute once saveDatabase is called.
     autoSave: true,
     autoSaveInterval: 5000,
     autoLoad: true,
     autoLoadCallback: null,
-  }
 }
 
 class FsAdapter extends EventEmitter {
+  #parent;
   constructor(props = {}) {
     super();
+    this.name = "FsAdapter";
+
     if(props.parent){
-      this.parent = props.parent
+      this.setParent(props.parent)
     }
     this.leafs = (props.leafs) ? props.leafs : {};
-    this.options = {
-      path: (props.path) ? (props.path) : defaultProps.options.path,
-      autoSave: (props.autoSave !== undefined) ? (props.autoSave) : defaultProps.options.autoSave,
-      autoSaveInterval: (props.autoSaveInterval !== undefined) ? (props.autoSaveInterval) : defaultProps.options.autoSaveInterval,
-      autoLoad: (props.autoLoad !== undefined) ? (props.autoLoad) : defaultProps.options.autoLoad,
-      autoLoadCallback: (props.autoLoadCallback !== undefined) ? (props.autoLoadCallback) : defaultProps.options.autoLoadCallback,
-    }
-    if (!this.options.autoLoad && this.options.autoLoadForceOverwrite === undefined) {
+    this.path= (props.path) ? (props.path) : defaultProps.path;
+    this.autoSave= (props.autoSave !== undefined) ? (props.autoSave) : defaultProps.autoSave;
+    this.autoSaveInterval= (props.autoSaveInterval !== undefined) ? (props.autoSaveInterval) : defaultProps.autoSaveInterval;
+    this.autoLoad= (props.autoLoad !== undefined) ? (props.autoLoad) : defaultProps.autoLoad;
+    this.autoLoadCallback= (props.autoLoadCallback !== undefined) ? (props.autoLoadCallback) : defaultProps.autoLoadCallback;
+
+    if (!this.autoLoad && this.autoLoadForceOverwrite === undefined) {
       throw new Error('Not implemented : Overwrite graceful handle. Pass autoLoadForceOverwrite to force.');
     }
     this.lastChange = null;
     this.lastSave = null;
     this.queue = new FSLock();
+    this.isReady = true;
+    if(props.leafs){
+      this.isReady = false;
+    }
+  }
+  setParent(parent){
+    this.#parent = parent;
+  }
+  getParent(){
+    return this.#parent;
   }
 };
 //TODO : Optimization possible by just removing the LeafMeta from memory for disk instead, but existance search will be slower.
@@ -40,7 +50,9 @@ FsAdapter.prototype.attachParent = require('./methods/attachParent');
 FsAdapter.prototype.addInLeaf = require('./methods/addInLeaf')
 FsAdapter.prototype.createLeaf = require('./methods/createLeaf')
 FsAdapter.prototype.findInLeaf = require('./methods/findInLeaf')
-FsAdapter.prototype.findAllInLeaf = require('./methods/findAllInLeaf')
+FsAdapter.prototype.getAllInLeaf = require('./methods/getAllInLeaf')
+FsAdapter.prototype.getLeftInLeaf = require('./methods/getLeftInLeaf')
+FsAdapter.prototype.getRightInLeaf = require('./methods/getRightInLeaf')
 FsAdapter.prototype.getDocument = require('./methods/getDocument')
 FsAdapter.prototype.insertSortedInLeaf = require('./methods/insertSortedInLeaf')
 FsAdapter.prototype.loadDatabase = require('./methods/loadDatabase')

src/adapters/FsAdapter/methods/addInLeaf.js

@@ -1,14 +1,14 @@
 const {insertSorted} = require('../../../utils/array');
 
-async function addInLeaf(leafName, field, identifier, key) {
+async function addInLeaf(leafName, identifier, value) {
   if (!this.leafs[leafName]) {
     await this.createLeaf(leafName);
   }
   if(this.leafs[leafName].meta.identifiers.includes(identifier)){
     //TODO : except unique:false?
-    throw new Error(`Key ${identifier} already exist`);
+    throw new Error(`Identifier ${identifier} already exist`);
   }
-  const index = await this.insertSortedInLeaf(leafName, key)
+  const index = await this.insertSortedInLeaf(leafName, value)
   this.leafs[leafName].meta.size += 1;
   this.leafs[leafName].meta.identifiers.splice(index, 0, identifier);
 

src/adapters/FsAdapter/methods/attachParent.js

@@ -1,8 +1,8 @@
 const autosave = require('./ops/autosave')
 async function attachParent(parent) {
-  this.parent = parent;
+  this.setParent(parent);
 
-  if (this.options.autoLoad) {
+  if (this.autoLoad) {
     try{
       await this.loadDatabase()
       if (this.autoLoadCallback && typeof this.autoLoadCallback === 'function') {
@@ -13,7 +13,7 @@ async function attachParent(parent) {
       process.exit(1);
     }
   };
-  if (this.options.autoSave === true) {
+  if (this.autoSave === true) {
     autosave(this);
   }
   this.emit('ready');

src/adapters/FsAdapter/methods/createLeaf.js

@@ -1,11 +1,11 @@
 const LeafData = require('../types/LeafData/LeafData')
 const LeafMeta = require('../types/LeafMeta/LeafMeta')
-module.exports = async function createLeaf(leafName){
-  this.leafs[leafName] = {
-    name: leafName,
+module.exports = async function createLeaf(leafId){
+  this.leafs[leafId] = {
+    id: leafId,
     meta: new LeafMeta()
   };
 
   const data = new LeafData();
-  await this.saveLeafData(leafName, data)
+  await this.saveLeafData(leafId, data)
 }

src/adapters/FsAdapter/methods/findInLeaf.js

@@ -1,14 +1,18 @@
 const getStrictMatchingKeys = require('./ops/getStrictMatchingKeys');
 const lowerThanKeys = require('./ops/lowerThanKeys');
 const greaterThanKeys = require('./ops/greaterThanKeys');
-module.exports = async function findInLeaf(leafName, key, op = '$eq') {
-  let {keys} = await this.openLeafData(leafName);
+module.exports = async function findInLeaf(leafId, value, op = '$eq') {
+  const result = {
+    identifiers:[],
+    keys:[]
+  };
+  let {keys} = await this.openLeafData(leafId);
   if (!keys) {
-    console.error(`Leafname ${leafName} was not present, had to recreate`)
-    await this.createLeaf(leafName);
-    return this.findInLeaf(leafName, key, op);
+    console.error(`leafId ${leafId} was not present, had to recreate`)
+    await this.createLeaf(leafId);
+    return this.findInLeaf(leafId, value, op);
   }
-  const strictMatchingKeys = getStrictMatchingKeys(keys, key);
+  const strictMatchingKeys = getStrictMatchingKeys(keys, value);
 
   switch (op) {
     case "$eq":
@@ -17,34 +21,57 @@ module.exports = async function findInLeaf(leafName, key, op = '$eq') {
       }
       const start = strictMatchingKeys[0];
       const end = strictMatchingKeys[0]+strictMatchingKeys.length;
-      return this.leafs[leafName].meta.identifiers.slice(start, end);
+
+      result.identifiers.push(...this.leafs[leafId].meta.identifiers.slice(start, end));
+      result.keys.push(...keys.slice(start, end));
+
+      return result;
+      // return this.leafs[leafName].meta.identifiers.slice(start, end);
     case "$lte":
       let resLte = [];
-      resLte = resLte.concat(await this.findInLeaf(leafName, key, '$lt'));
-      resLte = resLte.concat(await this.findInLeaf(leafName, key, '$eq'));
+      resLte = resLte.concat(await this.findInLeaf(leafId, value, '$lt'));
+      resLte = resLte.concat(await this.findInLeaf(leafId, value, '$eq'));
+      throw new Error('Modification to new format')
       return resLte;
     case "$gte":
       let resGte = [];
-      resGte = resGte.concat(await this.findInLeaf(leafName, key, '$eq'));
-      resGte = resGte.concat(await this.findInLeaf(leafName, key, '$gt'));
+      resGte = resGte.concat(await this.findInLeaf(leafId, value, '$eq'));
+      resGte = resGte.concat(await this.findInLeaf(leafId, value, '$gt'));
+      throw new Error('Modification to new format')
       return resGte;
     case "$lt":
       if(strictMatchingKeys.length){
-        const localIndex = keys.indexOf(key);
-        return (localIndex===0) ? [] : this.leafs[leafName].meta.identifiers.slice(0, localIndex);
+        const localIndex = keys.indexOf(value);
+        if(localIndex!==0){
+          result.identifiers.push(...this.leafs[leafId].meta.identifiers.slice(0, localIndex));
+          result.keys.push(...keys.slice(0, localIndex));
+        }
+        // return (localIndex===0) ? [] : this.leafs[leafId].meta.identifiers.slice(0, localIndex);
       }else{
-        const ltKeys = lowerThanKeys(keys, key);
-        return this.leafs[leafName].meta.identifiers.slice(0, ltKeys.length);
+        const ltKeys = lowerThanKeys(keys, value);
+
+        result.identifiers.push(...this.leafs[leafId].meta.identifiers.slice(0, ltKeys.length));
+        result.keys.push(...keys.slice(0, ltKeys.length));
+
+        // return this.leafs[leafId].meta.identifiers.slice(0, ltKeys.length);
       }
+      return result;
     case "$gt":
       if(strictMatchingKeys.length){
-        const localIndex = keys.indexOf(key);
-        return (localIndex===-1) ? [] : this.leafs[leafName].meta.identifiers.slice(localIndex+strictMatchingKeys.length);
+        const localIndex = keys.indexOf(value);
+        if(localIndex !== -1){
+          result.identifiers.push(...this.leafs[leafId].meta.identifiers.slice(localIndex+strictMatchingKeys.length));
+          result.keys.push(...keys.slice(localIndex+strictMatchingKeys.length));
+        }
       }else{
-        const _keys = greaterThanKeys(keys, key);
+        const _keys = greaterThanKeys(keys, value);
         const len = (_keys.length<=0) ? 0 : _keys.length;
-        return (len===0) ? [] :this.leafs[leafName].meta.identifiers.slice(-len);
+        if(leafId!==0){
+          result.identifiers.push(...this.leafs[leafId].meta.identifiers.slice(-len));
+          result.keys.push(...keys.slice(-len));
+        }
       }
+      return result;
     default:
       throw new Error(`Unsupported operator ${op}`);
   }

src/adapters/FsAdapter/methods/getAllInLeaf.js

@@ -0,0 +1,10 @@
+module.exports = async function getAllInLeaf(leafId){
+
+  let {keys} = await this.openLeafData(leafId);
+  if(!keys){
+    console.error(`leafId ${leafId} was not present, had to recreate`)
+    await this.createLeaf(leafId);
+    return this.getAllInLeaf(leafId);
+  }
+  return JSON.parse(JSON.stringify({identifiers:this.leafs[leafId].meta.identifiers, keys:keys}));
+}

src/adapters/FsAdapter/methods/getDocument.js

@@ -1,3 +1,3 @@
 module.exports = async function getDocument(identifier){
-  return this.openDocument(identifier);
+  return JSON.parse(JSON.stringify(this.openDocument(identifier)));
 }

src/adapters/FsAdapter/methods/getLeftInLeaf.js

@@ -0,0 +1,15 @@
+module.exports = async function getLeftInLeaf(leafId){
+
+  let {keys} = await this.openLeafData(leafId);
+  if(!keys){
+    console.error(`leafId ${leafId} was not present, had to recreate`)
+    await this.createLeaf(leafId);
+    return this.getLeftInLeaf(leafId);
+  }
+
+  const leaf = this.leafs[leafId];
+  const identifier = leaf.meta.identifiers[0];
+  const key = leaf.data.keys[0];
+
+  return JSON.parse(JSON.stringify({identifier, key }))
+}

src/adapters/FsAdapter/methods/getRightInLeaf.js

@@ -0,0 +1,16 @@
+module.exports = async function getRightInLeaf(leafId){
+
+  let {keys} = await this.openLeafData(leafId);
+  if(!keys){
+    console.error(`leafId ${leafId} was not present, had to recreate`)
+    await this.createLeaf(leafId);
+    return this.getLeftInLeaf(leafId);
+  }
+
+  const leaf = this.leafs[leafId];
+  const len = leaf.meta.identifiers.length;
+  const identifier = leaf.meta.identifiers[len-1];
+  const key = leaf.data.keys[len-1];
+
+  return JSON.parse(JSON.stringify({identifier, key }))
+}

src/adapters/FsAdapter/methods/insertSortedInLeaf.js

@@ -1,12 +1,12 @@
 const {insertSorted} = require('../../../utils/array')
-module.exports = async function insertSortedInLeaf(leafName, key){
-  const data = await this.openLeafData(leafName);
+module.exports = async function insertSortedInLeaf(leafId, value){
+  const data = await this.openLeafData(leafId);
   if(!data || !data.keys){
-    console.error(`Leafname ${leafName} was not present, had to recreate`)
-    await this.createLeaf(leafName);
-    return this.insertSortedInLeaf(leafName, key)
+    console.error(`leafId ${leafId} was not present, had to recreate`)
+    await this.createLeaf(leafId);
+    return this.insertSortedInLeaf(leafId, value)
   }
-  const index = insertSorted(data.keys,key);
-  await this.saveLeafData(leafName, data)
+  const index = insertSorted(data.keys,value);
+  await this.saveLeafData(leafId, data)
   return index;
 }