bahdb.bah

#include "iostream.bah"
#include "thread.bah"
#include "rand.bah"
#import "json.bah"

#define! usleep(i int)
#define! atexit(p ptr) int

const DEFAULT_HEADER_SIZE = 32768

struct bahDB_ref {
    field: cpstring
    value: cpstring
    ref: int
    pos: int
    next: int = -1
}

struct bahDB_entry {
    data: cpstring
    avail: int
    pos: int
}

struct bahDB_vacant {
    pos: int
    size: int
}

struct bahDB__header {
    indexes: []bahDB_ref*
    freePos: []bahDB_vacant*
    lastPos: int = 0
    dataPos: int = DEFAULT_HEADER_SIZE
}

__db_remove_pos(pos []int, ref int) {
    isInside = false
    i=0; for i < len(pos), i++ {
        if pos[i] == ref {
            isInside = true
            break
        }
    }
    if isInside == false {
        return
    }
    i++; for i < len(pos), i++ {
        pos[i-1] = pos[i]
    }
    l = len(pos)
    noCheck(pos->length = l - 1)

}

#include "syntax.bah"

__bahDB_mutex = []cpstring

    //INTERNAL FUNCTION
__bahDB_deleteMutexes() {
    i=0; for i < len(__bahDB_mutex), i++ {
        removeFile(__bahDB_mutex[i])
    }
}

    //INTERNAL FUNCTION
__bahDB_ok_exit = atexit(__bahDB_deleteMutexes)

struct bahDB {
    fm: fileMap
    name: cpstring
    m: cpstring
    
    //INTERNAL FUNCTION
    lock() {
        for mkdir(this.m, 600) == -1 {
            usleep(300)
        }
    }
    //INTERNAL FUNCTION
    unlock() {
        removeFile(this.m)
    }

    //INTERNAL FUNCTION
    grow(nb int) {
        this.fm.close()
        fs = fileStream{}
        fs.open(this.name, "a")
        i=0; for i < nb + 10, i++ {
            fs.writeFile(" ")
        }
        fs.close()
        this.fm.open(this.name)
    }

    //INTERNAL FUNCTION
    getAtOffset(i int) cpstring {
        p cpstring = this.fm.p
        return noCheck(p + i)
    }

    //INTERNAL FUNCTION
    getChar(i int) char {
        p cpstring = this.fm.p
        return noCheck(p[i])
    }

    //INTERNAL FUNCTION
    write(s cpstring, pos int) {
        memcpy(this.getAtOffset(pos), s, strlen(s))
    }

    //INTERNAL FUNCTION
    serialHeader(h bahDB__header*) {
        j = toJson(h)
        this.write(intToStr(strlen(j))+"\n"+j, 0)
    }

    //INTERNAL FUNCTION
    loadHeader() bahDB__header* {
        h = new bahDB__header
        nbs = []char
        c = '0'
        i=0; for isNumber(c), i++ {
            nbs[i] = c
            c = this.getChar(i)
        }
        nbs[i] = <char>0
        size = strToInt(arrAsStr(nbs))
        s = memoryAlloc(size + 1)
        memcpy(s, this.getAtOffset(i), size)
        j = parseJson(s)
        j.scan(h)
        return h
    }

    //INTERNAL FUNCTION
    readAtPos(i int, e reflectElement) {

        c = this.getChar(i)

        for isNumber(c) == 0, i++ {
            c = this.getChar(i)
        }
        i--

        nbs = []char
        c = '0'
        for isNumber(c), i++ {
            nbs[len(nbs)] = c
            c = this.getChar(i)
        }
        nbs[len(nbs)] = <char>0
        size = strToInt(arrAsStr(nbs))
        s = memoryAlloc(size + 1)
        memcpy(s, this.getAtOffset(i), size)

        j = parseJson(s)
        j.scan(e)
    }

    //INTERNAL FUNCTION
    readJsonAtPos(i int) cpstring {
        c = this.getChar(i)
        for isSpace(c), i++ {
            c = this.getChar(i)
        }
        i--
        nbs = []char
        c = '0'
        for isNumber(c), i++ {
            nbs[len(nbs)] = c
            c = this.getChar(i)
        }
        nbs[len(nbs)] = <char>0
        size = strToInt(arrAsStr(nbs))
        s = memoryAlloc(size + 1)
        memcpy(s, this.getAtOffset(i), size)
        return s
    }

    //INTERNAL FUNCTION
    getFreePos(s int, h bahDB__header*) int {
        i=0; for i < len(h.freePos), i++ {
            v = h.freePos[i]
            if v.size >= s {
                return v.pos
            }
        }
        return -1
    }

    //INTERNAL FUNCTION
    getSize(e reflectElement) int {
        j = toJson(e)
        size = strlen(j)
        serS = intToStr(size)
        size = size + strlen(serS) + 2
        return size
    }

    //INTERNAL FUNCTION
    append(e reflectElement, h bahDB__header*) {
        j = toJson(e)
        size = strlen(j)
        serS = intToStr(size)
        j = "\n"+serS+"\n"+j
        size = size + strlen(serS) + 2
        
        // indfrp = []bahDB_vacant*
        // i=0; for i < len(h.freePos), i++ {
        //     indfrp[i] = h.freePos[i]
        // }

        found = false
        // i=0; for i < len(indfrp), i++ {
        //     v = indfrp[i]
        //     if v.size >= size {
        //         found = true
        //         //set vpos
        //         this.write(j, v.pos + h.dataPos)
        //         k=i+1; for k < len(h.freePos), k++ {
        //             h.freePos[k-1] = h.freePos[k]
        //         }
        //         l = len(h.freePos)
        //         if l == 1 {
        //             h.freePos = []bahDB_vacant*
        //         } else {
        //             noCheck(h.freePos->length = l-1)
        //         }
        //         break
        //     }
        // }
        
        if found == false {
            avail = this.fm.size - h.lastPos - h.dataPos
            if avail < size {
                this.grow(size - avail)
            }
            this.write(j, h.lastPos + h.dataPos)
            h.lastPos = h.lastPos + size
        }
    }

    //INTERNAL FUNCTION
    appendEntry(e bahDB_entry*, h bahDB__header*) {
        e.pos = h.lastPos
        j = toJson(e)
        size = strlen(j)
        serS = intToStr(size)
        j = "\n"+serS+"\n"+j
        size = size + strlen(serS) + 2
        
        indfrp = []bahDB_vacant*
        i=0; for i < len(h.freePos), i++ {
            indfrp[i] = h.freePos[i]
        }

        found = false
        i=0; for i < len(indfrp), i++ {
            v = indfrp[i]
            if v.size >= size {
                e.pos = v.pos
                j = toJson(e)
                size = strlen(j)
                serS = intToStr(size)
                j = "\n"+serS+"\n"+j
                size = size + strlen(serS) + 2
                if v.size < size {
                    continue
                }
                found = true
                this.write(j, v.pos + h.dataPos)
                k=i+1; for k < len(h.freePos), k++ {
                    h.freePos[k-1] = h.freePos[k]
                }
                l = len(h.freePos)
                if l == 1 {
                    h.freePos = []bahDB_vacant*
                } else {
                    noCheck(h.freePos->length = l-1)
                }
                break
            }
        }

        if found == false {        
            avail = this.fm.size - h.lastPos - h.dataPos
            if avail < size {
                this.grow(size - avail)
            }
            this.write(j, h.lastPos + h.dataPos)
            h.lastPos = h.lastPos + size
        }
    }

    //INTERNAL FUNCTION
    insertReference(r bahDB_ref*, h bahDB__header*) {
        i=0; for i < len(h.indexes), i++ {
            ind = h.indexes[i]
            if ind.field == r.field {
                r.pos = 0
                // ind.pos = this.getFreePos(this.getSize(ind), h)
                // if ind.pos == -1 {
                    ind.pos = h.lastPos
                // }
                r.next = ind.pos
                this.append(ind, h)
                h.indexes[i] = r
                return
            }
        }
        h.indexes[len(h.indexes)] = r
    }

    //INTERNAL FUNCTION
    insertReferences(e bahDB_entry*, el reflectElement, h bahDB__header*) []bahDB_ref* {
        ret = []bahDB_ref*
        i=0; for i < len(el.structLayout), i++ {
            f = el.structLayout[i]
            f.value = f.calculateOffset(el.value)
            ref = new bahDB_ref
            ref.ref = e.pos
            ref.field = f.name
            ref.value = toJson__inner(f, true, 0)
            this.insertReference(ref, h)
        }

        return ret
    }
    

    //INTERNAL FUNCTION
    getPos(parentCond bahDB_synax_operator*) []int {

        h = this.loadHeader()
        ret = []int
        firstIter = true
        i=0; for i < len(h.indexes), i++ {
            r = h.indexes[i]
            cond = parentCond.getField(r.field)
            if cond != null {
                if cond.check(r.value) {
                    if firstIter == true {
                        ret[len(ret)] = r.ref
                    }
                } else {
                    __db_remove_pos(ret, r.ref)
                }
                n = r
                for n.next != -1 {
                    next = n.next
                    n = new bahDB_ref

                    this.readAtPos(next + h.dataPos, n)
                    if cond.check(n.value) {
                        if firstIter == true {
                            ret[len(ret)] = n.ref
                        }
                    } else {
                        __db_remove_pos(ret, n.ref)
                    }
                }
                firstIter = false
            }
        }

        return ret
    }

    //INTERNAL FUNCTION
    deleteByPos(i int, h bahDB__header*) {
        c = this.getChar(i)
        for isSpace(c), i++ {
            c = this.getChar(i)
        }
        i--
        start = i
        nbs = []char
        c = '0'
        for isNumber(c), i++ {
            nbs[len(nbs)] = c
            c = this.getChar(i)
        }
        nbs[len(nbs)] = <char>0
        size = strToInt(arrAsStr(nbs))
        blockSize = size + len(nbs) - 1
        v = new bahDB_vacant
        v.pos = start - h.dataPos
        v.size = blockSize

        found = false
        i=0; for i < len(h.freePos), i++ {
            fp = h.freePos[i]
            downMerge = v.pos - fp.pos - fp.size
            upMerge = fp.pos - v.pos - v.size
            isMerged = false
            if downMerge <= 10 && downMerge > 0 {
                found = true
                fp.size = fp.size + v.size
                v = fp
                isMerged = true
            }
            if upMerge <= 10 && upMerge > 0 {
                found = true
                fp.pos = v.pos
                fp.size = fp.size + v.size
                isMerged = true
            }
            if isMerged == true {
                break
            }
        }
        if found == false {
            h.freePos[len(h.freePos)] = v
        }
        memset(this.getAtOffset(start), <int>' ', blockSize)
    }

    //INTERNAL FUNCTION
    deleteRefs(e jsonElement*, pos int, h bahDB__header*) {



        refInd = []bahDB_ref*
        i=0; for i < len(h.indexes), i++ {
            refInd[i] = h.indexes[i]
        }

        i=0; for i < len(refInd), i++ {
            ind = refInd[i]

            if ind.ref == pos {

                if ind.next != -1 {
                    n = new bahDB_ref
                    this.readAtPos(ind.next + h.dataPos, n)
                    h.indexes[i] = n
                    this.deleteByPos(n.pos + h.dataPos, h)
                } else {
                    k=i+1; for k < len(h.indexes), k++ {
                        h.indexes[k-1] = h.indexes[k]
                    }
                    l = len(h.indexes)
                    if l == 1 {
                        h.indexes = []bahDB_ref*
                    } else {
                        noCheck(h.indexes->length = l-1)
                    }
                }
                continue
            }
            n = ind
            p bahDB_ref*
            for n.next != -1 {
                next = n.next
                p = n
                n = new bahDB_ref
                this.readAtPos(next + h.dataPos, n)
                if n.ref == pos {
                    


                    p.next = n.next
                    
                    isFirst = p in refInd

                    if isFirst == false {
                        j = toJson(p)
                        size = strlen(j)
                        serS = intToStr(size)
                        j = "\n"+serS+"\n"+j
                        size = size + strlen(serS) + 2
                        this.write(j, p.pos + h.dataPos)
                    }

                    this.deleteByPos(n.pos + h.dataPos, h)
                    break
                }
            }
        }
    }

    //Opens a new database with the specified file.
    //If non-existing or blank, a new database will be created.
    open(name cpstring) {
        fs = fileStream{}
        this.fm = fileMap{}
        this.name = name
        //creating mutex
        parts = splitString(string(name), "/")
        l = parts[len(parts)-1]
        l.prepend(".")
        l.append("_tmp")
        parts[len(parts)-1] = l
        m = joinString(parts, "/")
        this.m = m.str()
        __bahDB_mutex[len(__bahDB_mutex)] = this.m
        //making initial file
        fs.open(name, "r")
        if fs.isValid() == 0 || fs.getSize() == 0 {
            fs.createFile(name)
            this.grow(DEFAULT_HEADER_SIZE)
            h = new bahDB__header
            h.dataPos = DEFAULT_HEADER_SIZE
            h.lastPos = 0
            this.serialHeader(h)
        } else {
            fs.close()
            this.fm.open(name)
        }
    }
    
    //Closes a database.
    //Must be called at some point if you .open() a database.
    close() {
        this.fm.close()
    }

    //Inserts an element to the database.
    //Pass it a pointer to any structure.
    insert(e reflectElement) {
        this.lock()
        
        h = this.loadHeader()
        
        entry = new bahDB_entry
        entry.data = toJson(e)
        this.appendEntry(entry, h)

        this.insertReferences(entry, e, h)
        
        this.serialHeader(h)

        this.unlock()
    }

    //Selects element(s) from the database where the condition is respected.
    //select(field, value, element)
    //  field: the field to check
    //  value: the value of the field
    //  element: a pointer to the structure that needs to be scaned.
    //           This can be either an array of pointer (of the struct's type)
    //           or a single pointer to a structure (that needs to be allocated with new).
    select(cond bahDB_synax_operator*, e reflectElement) {
        this.lock()
        h = this.loadHeader()
        pos = this.getPos(cond)

        if e.isArray == false && len(pos) > 0 {
            entry = new bahDB_entry
            this.readAtPos(pos[0] + h.dataPos, entry)
            j = parseJson(entry.data)
            j.scan(e)
        } else {
            entry = new bahDB_entry
            s = "["
            i=0; for i < len(pos), i++ {
                if i != 0 {
                    s = s + ","
                }

                this.readAtPos(pos[i] + h.dataPos, entry)
                s = s + entry.data
            }
            s = s + "]"
            j = parseJson(s)
            j.scan(e)
        }

        this.unlock()
    }

    //Deletes element(s) from the database.
    //delete(field, value)
    //  field: the field to check
    //  value: the value of the field
    delete(cond bahDB_synax_operator*) {
        this.lock()
        h = this.loadHeader()
        pos = this.getPos(cond)

        entry = new bahDB_entry
        i=0; for i < len(pos), i++ {

            this.readAtPos(pos[i] + h.dataPos, entry)
            j = parseJson(entry.data)
            this.deleteRefs(j, pos[i], h)

            this.deleteByPos(pos[i] + h.dataPos, h)
            this.serialHeader(h)
        }


        this.unlock()
    }

    //Updates element(s) of the database.
    //update(field, value, template, setField, setValue)
    //  field: the field to check
    //  value: the value of the field
    //  template: a structure used as a template (containing the fields of the element, must be empty)
    //  setField: the field that needs to be updated
    //  setValue: the new value for that field
    update(cond bahDB_synax_operator*, e reflectElement, vals bahDB_synax_setter*) {
        this.lock()
        h = this.loadHeader()
        pos = this.getPos(cond)

        entry = new bahDB_entry
        i=0; for i < len(pos), i++ {
            //fetch old data
            this.readAtPos(pos[i] + h.dataPos, entry)
            j = parseJson(entry.data)
            j.scan(e)
            k=0; for k < len(e.structLayout), k++ {
                m = e.structLayout[k]
                val = vals.getField(m.name)
                if val != null {
                    mv ptr* = m.value
                    *mv = val.val.value
                    e.structLayout[k] = m
                }
            }


            //remove old data
            this.readAtPos(pos[i] + h.dataPos, entry)
            j = parseJson(entry.data)
            this.deleteRefs(j, pos[i], h)
            this.deleteByPos(pos[i] + h.dataPos, h)
            this.serialHeader(h)

            //place new data
            entry = new bahDB_entry
            entry.data = toJson(e)
            this.appendEntry(entry, h)
            this.insertReferences(entry, e, h)
            this.serialHeader(h)

        }

        this.unlock()
    }

}