dvdatabase.c

DataDraw is an ultra-fast persistent database for high performance programs written in C. It s so fa

/*----------------------------------------------------------------------------------------
  Database dv
----------------------------------------------------------------------------------------*/

#include "dvdatabase.h"

union dvTempType_ dvTemp_;
struct dvRootType_ dvRootData;
uint8 dvModuleID;
struct dvRootFields dvRoots;
struct dvModpathFields dvModpaths;
struct dvModuleFields dvModules;
struct dvLinkFields dvLinks;
struct dvSchemaFields dvSchemas;
struct dvEnumFields dvEnums;
struct dvEntryFields dvEntrys;
struct dvTypedefFields dvTypedefs;
struct dvClassFields dvClasss;
struct dvPropertyFields dvPropertys;
struct dvRelationshipFields dvRelationships;
struct dvUnionFields dvUnions;
struct dvCaseFields dvCases;

/*----------------------------------------------------------------------------------------
  Constructor/Destructor hooks.
----------------------------------------------------------------------------------------*/
void(*dvRootConstructorCallback)(dvRoot);
void(*dvModpathConstructorCallback)(dvModpath);
void(*dvModuleConstructorCallback)(dvModule);
void(*dvLinkConstructorCallback)(dvLink);
void(*dvSchemaConstructorCallback)(dvSchema);
void(*dvEnumConstructorCallback)(dvEnum);
void(*dvEntryConstructorCallback)(dvEntry);
void(*dvTypedefConstructorCallback)(dvTypedef);
void(*dvClassConstructorCallback)(dvClass);
void(*dvPropertyConstructorCallback)(dvProperty);
void(*dvRelationshipConstructorCallback)(dvRelationship);
void(*dvUnionConstructorCallback)(dvUnion);
void(*dvUnionDestructorCallback)(dvUnion);
void(*dvCaseConstructorCallback)(dvCase);
void(*dvCaseDestructorCallback)(dvCase);

/*----------------------------------------------------------------------------------------
  Default constructor wrapper for the database manager.
----------------------------------------------------------------------------------------*/
static uint64 allocRoot(void)
{
    dvRoot Root = dvRootAlloc();

    return dvRoot2Index(Root);
}

/*----------------------------------------------------------------------------------------
  Allocate the field arrays of Root.
----------------------------------------------------------------------------------------*/
static void allocRoots(void)
{
    dvSetAllocatedRoot(2);
    dvSetUsedRoot(0);
    dvRoots.FirstModpath = utNewA(dvModpath, (dvAllocatedRoot()));
    dvRoots.LastModpath = utNewA(dvModpath, (dvAllocatedRoot()));
    dvRoots.ModpathTableIndex = utNewA(uint32, (dvAllocatedRoot()));
    dvRoots.NumModpathTable = utNewA(uint32, (dvAllocatedRoot()));
    dvSetUsedRootModpathTable(0);
    dvSetAllocatedRootModpathTable(2);
    dvSetFreeRootModpathTable(0);
    dvRoots.ModpathTable = utNewA(dvModpath, dvAllocatedRootModpathTable());
    dvRoots.NumModpath = utNewA(uint32, (dvAllocatedRoot()));
    dvRoots.FirstModule = utNewA(dvModule, (dvAllocatedRoot()));
    dvRoots.LastModule = utNewA(dvModule, (dvAllocatedRoot()));
    dvRoots.ModuleTableIndex = utNewA(uint32, (dvAllocatedRoot()));
    dvRoots.NumModuleTable = utNewA(uint32, (dvAllocatedRoot()));
    dvSetUsedRootModuleTable(0);
    dvSetAllocatedRootModuleTable(2);
    dvSetFreeRootModuleTable(0);
    dvRoots.ModuleTable = utNewA(dvModule, dvAllocatedRootModuleTable());
    dvRoots.NumModule = utNewA(uint32, (dvAllocatedRoot()));
}

/*----------------------------------------------------------------------------------------
  Realloc the arrays of properties for class Root.
----------------------------------------------------------------------------------------*/
static void reallocRoots(
    uint32 newSize)
{
    utResizeArray(dvRoots.FirstModpath, (newSize));
    utResizeArray(dvRoots.LastModpath, (newSize));
    utResizeArray(dvRoots.ModpathTableIndex, (newSize));
    utResizeArray(dvRoots.NumModpathTable, (newSize));
    utResizeArray(dvRoots.NumModpath, (newSize));
    utResizeArray(dvRoots.FirstModule, (newSize));
    utResizeArray(dvRoots.LastModule, (newSize));
    utResizeArray(dvRoots.ModuleTableIndex, (newSize));
    utResizeArray(dvRoots.NumModuleTable, (newSize));
    utResizeArray(dvRoots.NumModule, (newSize));
    dvSetAllocatedRoot(newSize);
}

/*----------------------------------------------------------------------------------------
  Allocate more Roots.
----------------------------------------------------------------------------------------*/
void dvRootAllocMore(void)
{
    reallocRoots(dvAllocatedRoot() + (dvAllocatedRoot() >> 1));
}

/*----------------------------------------------------------------------------------------
  Compact the Root.ModpathTable heap to free memory.
----------------------------------------------------------------------------------------*/
void dvCompactRootModpathTables(void)
{
    uint32 elementSize = sizeof(dvModpath);
    uint32 usedHeaderSize = (sizeof(dvRoot) + elementSize - 1)/elementSize;
    uint32 freeHeaderSize = (sizeof(dvRoot) + sizeof(uint32) + elementSize - 1)/elementSize;
    dvModpath *toPtr = dvRoots.ModpathTable;
    dvModpath *fromPtr = toPtr;
    dvRoot Root;
    uint32 size;

    while(fromPtr < dvRoots.ModpathTable + dvUsedRootModpathTable()) {
        Root = *(dvRoot *)(void *)fromPtr;
        if(Root != dvRootNull) {
            /* Need to move it to toPtr */
            size = utMax(dvRootGetNumModpathTable(Root) + usedHeaderSize, freeHeaderSize);
            memmove((void *)toPtr, (void *)fromPtr, size*elementSize);
            dvRootSetModpathTableIndex(Root, toPtr - dvRoots.ModpathTable + usedHeaderSize);
            toPtr += size;
        } else {
            /* Just skip it */
            size = *(uint32 *)(void *)(((dvRoot *)(void *)fromPtr) + 1);
        }
        fromPtr += size;
    }
    dvSetUsedRootModpathTable(toPtr - dvRoots.ModpathTable);
    dvSetFreeRootModpathTable(0);
}

/*----------------------------------------------------------------------------------------
  Allocate more memory for the Root.ModpathTable heap.
----------------------------------------------------------------------------------------*/
static void allocMoreRootModpathTables(
    uint32 spaceNeeded)
{
    uint32 freeSpace = dvAllocatedRootModpathTable() - dvUsedRootModpathTable();

    if((dvFreeRootModpathTable() << 2) > dvUsedRootModpathTable()) {
        dvCompactRootModpathTables();
        freeSpace = dvAllocatedRootModpathTable() - dvUsedRootModpathTable();
    }
    if(freeSpace < spaceNeeded) {
        dvSetAllocatedRootModpathTable(dvAllocatedRootModpathTable() + spaceNeeded - freeSpace +
            (dvAllocatedRootModpathTable() >> 2));
        utResizeArray(dvRoots.ModpathTable, dvAllocatedRootModpathTable());
    }
}

/*----------------------------------------------------------------------------------------
  Allocate memory for a new Root.ModpathTable array.
----------------------------------------------------------------------------------------*/
void dvRootAllocModpathTables(
    dvRoot Root,
    uint32 numModpathTables)
{
    uint32 freeSpace = dvAllocatedRootModpathTable() - dvUsedRootModpathTable();
    uint32 elementSize = sizeof(dvModpath);
    uint32 usedHeaderSize = (sizeof(dvRoot) + elementSize - 1)/elementSize;
    uint32 freeHeaderSize = (sizeof(dvRoot) + sizeof(uint32) + elementSize - 1)/elementSize;
    uint32 spaceNeeded = utMax(numModpathTables + usedHeaderSize, freeHeaderSize);

#if defined(DD_DEBUG)
    utAssert(dvRootGetNumModpathTable(Root) == 0);
#endif
    if(numModpathTables == 0) {
        return;
    }
    if(freeSpace < spaceNeeded) {
        allocMoreRootModpathTables(spaceNeeded);
    }
    dvRootSetModpathTableIndex(Root, dvUsedRootModpathTable() + usedHeaderSize);
    dvRootSetNumModpathTable(Root, numModpathTables);
    *(dvRoot *)(void *)(dvRoots.ModpathTable + dvUsedRootModpathTable()) = Root;
    memset(dvRootGetModpathTables(Root), 0xff, numModpathTables*elementSize);
    dvSetUsedRootModpathTable(dvUsedRootModpathTable() + spaceNeeded);
}

/*----------------------------------------------------------------------------------------
  Wrapper around dvRootGetModpathTables for the database manager.
----------------------------------------------------------------------------------------*/
static void *getRootModpathTables(
    uint64 objectNumber,
    uint32 *numValues)
{
    dvRoot Root = dvIndex2Root(objectNumber);

    *numValues = dvRootGetNumModpathTable(Root);
    return dvRootGetModpathTables(Root);
}

/*----------------------------------------------------------------------------------------
  Wrapper around dvRootAllocModpathTables for the database manager.
----------------------------------------------------------------------------------------*/
static void *allocRootModpathTables(
    uint64 objectNumber,
    uint32 numValues)
{
    dvRoot Root = dvIndex2Root(objectNumber);

    dvRootSetModpathTableIndex(Root, 0);
    dvRootSetNumModpathTable(Root, 0);
    if(numValues == 0) {
        return NULL;
    }
    dvRootAllocModpathTables(Root, numValues);
    return dvRootGetModpathTables(Root);
}

/*----------------------------------------------------------------------------------------
  Free memory used by the Root.ModpathTable array.
----------------------------------------------------------------------------------------*/
void dvRootFreeModpathTables(
    dvRoot Root)
{
    uint32 elementSize = sizeof(dvModpath);
    uint32 usedHeaderSize = (sizeof(dvRoot) + elementSize - 1)/elementSize;
    uint32 freeHeaderSize = (sizeof(dvRoot) + sizeof(uint32) + elementSize - 1)/elementSize;
    uint32 size = utMax(dvRootGetNumModpathTable(Root) + usedHeaderSize, freeHeaderSize);
    dvModpath *dataPtr = dvRootGetModpathTables(Root) - usedHeaderSize;

    if(dvRootGetNumModpathTable(Root) == 0) {
        return;
    }
    *(dvRoot *)(void *)(dataPtr) = dvRootNull;
    *(uint32 *)(void *)(((dvRoot *)(void *)dataPtr) + 1) = size;
    dvRootSetNumModpathTable(Root, 0);
    dvSetFreeRootModpathTable(dvFreeRootModpathTable() + size);
}

/*----------------------------------------------------------------------------------------
  Resize the Root.ModpathTable array.
----------------------------------------------------------------------------------------*/
void dvRootResizeModpathTables(
    dvRoot Root,
    uint32 numModpathTables)
{
    uint32 freeSpace = dvAllocatedRootModpathTable() - dvUsedRootModpathTable();
    uint32 elementSize = sizeof(dvModpath);
    uint32 usedHeaderSize = (sizeof(dvRoot) + elementSize - 1)/elementSize;
    uint32 freeHeaderSize = (sizeof(dvRoot) + sizeof(uint32) + elementSize - 1)/elementSize;
    uint32 newSize = utMax(numModpathTables + usedHeaderSize, freeHeaderSize);
    uint32 oldSize = utMax(dvRootGetNumModpathTable(Root) + usedHeaderSize, freeHeaderSize);
    dvModpath *dataPtr;

    if(numModpathTables == 0) {
        if(dvRootGetNumModpathTable(Root) != 0) {
            dvRootFreeModpathTables(Root);
        };
        return;
    }
    if(dvRootGetNumModpathTable(Root) == 0) {
        dvRootAllocModpathTables(Root, newSize);
        return;
    };
    if(freeSpace < newSize) {
        allocMoreRootModpathTables(newSize);
    }
    dataPtr = dvRootGetModpathTables(Root) - usedHeaderSize;
    memcpy((void *)(dvRoots.ModpathTable + dvUsedRootModpathTable()), dataPtr,
        elementSize*utMin(oldSize, newSize));
    if(newSize > oldSize) {
        memset(dvRoots.ModpathTable + dvUsedRootModpathTable() + oldSize, 0xff,
            elementSize*(newSize - oldSize));
    }
    *(dvRoot *)(void *)dataPtr = dvRootNull;
    *(uint32 *)(void *)(((dvRoot *)(void *)dataPtr) + 1) = oldSize;
    dvSetFreeRootModpathTable(dvFreeRootModpathTable() + oldSize);
    dvRootSetModpathTableIndex(Root, dvUsedRootModpathTable() + usedHeaderSize);
    dvRootSetNumModpathTable(Root, numModpathTables);
    dvSetUsedRootModpathTable(dvUsedRootModpathTable() + newSize);
}

/*----------------------------------------------------------------------------------------
  Compact the Root.ModuleTable heap to free memory.
----------------------------------------------------------------------------------------*/
void dvCompactRootModuleTables(void)
{
    uint32 elementSize = sizeof(dvModule);
    uint32 usedHeaderSize = (sizeof(dvRoot) + elementSize - 1)/elementSize;
    uint32 freeHeaderSize = (sizeof(dvRoot) + sizeof(uint32) + elementSize - 1)/elementSize;
    dvModule *toPtr = dvRoots.ModuleTable;
    dvModule *fromPtr = toPtr;
    dvRoot Root;
    uint32 size;

    while(fromPtr < dvRoots.ModuleTable + dvUsedRootModuleTable()) {
        Root = *(dvRoot *)(void *)fromPtr;
        if(Root != dvRootNull) {
            /* Need to move it to toPtr */
            size = utMax(dvRootGetNumModuleTable(Root) + usedHeaderSize, freeHeaderSize);
            memmove((void *)toPtr, (void *)fromPtr, size*elementSize);
            dvRootSetModuleTableIndex(Root, toPtr - dvRoots.ModuleTable + usedHeaderSize);
            toPtr += size;
        } else {
            /* Just skip it */
            size = *(uint32 *)(void *)(((dvRoot *)(void *)fromPtr) + 1);
        }
        fromPtr += size;
    }
    dvSetUsedRootModuleTable(toPtr - dvRoots.ModuleTable);
    dvSetFreeRootModuleTable(0);
}

/*----------------------------------------------------------------------------------------
  Allocate more memory for the Root.ModuleTable heap.
----------------------------------------------------------------------------------------*/
static void allocMoreRootModuleTables(
    uint32 spaceNeeded)
{
    uint32 freeSpace = dvAllocatedRootModuleTable() - dvUsedRootModuleTable();

    if((dvFreeRootModuleTable() << 2) > dvUsedRootModuleTable()) {
        dvCompactRootModuleTables();