fastdb/inc/compiler.h

//-< COMPILE.H >-----------------------------------------------------*--------*
// FastDB                    Version 1.0         (c) 1999  GARRET    *     ?  *
// (Main Memory Database Management System)                          *   /\|  *
//                                                                   *  /  \  *
//                          Created:     20-Nov-98    K.A. Knizhnik  * / [] \ *
//                          Last update: 17-Jan-99    K.A. Knizhnik  * GARRET *
//-------------------------------------------------------------------*--------*
// Conditional expresion compiler
//-------------------------------------------------------------------*--------*

#ifndef __COMPILER_H__
#define __COMPILER_H__

#include <setjmp.h>
#ifdef USE_REGEX
#include <regex.h>
#endif

BEGIN_FASTDB_NAMESPACE

#if defined(__osf__) || defined(__FreeBSD__)
#define longjmp(b,s) _longjmp(b,s) // do not restore signal context
#define setjmp(b)  _setjmp(b)
#endif

enum dbvmCodes {
#define DBVM(cop, type, n_operands, commutative) cop,
#ifdef VXWORKS
#include "compiler.dd"
#else
#include "compiler.d"
#endif // VXWORKS
dbvmLastCode
};

#define IS_CONSTANT(c) \
    (unsigned(c) - dbvmLoadVarBool <= (unsigned)dbvmLoadRectangleConstant - dbvmLoadVarBool)

enum nodeType {
    tpInteger,
    tpBoolean,
    tpReal,
    tpString,
    tpWString,
    tpReference,
    tpRectangle,
    tpArray,
    tpRawBinary,
    tpFreeVar,  // index of EXISTS clause
    tpList,     // list of expressions
    tpVoid
};

enum tokens {
    tkn_ident,
    tkn_lpar,
    tkn_rpar,
    tkn_lbr,
    tkn_rbr,
    tkn_dot,
    tkn_comma,
    tkn_power,
    tkn_iconst,
    tkn_sconst,
    tkn_fconst,
    tkn_add,
    tkn_sub,
    tkn_mul,
    tkn_div,
    tkn_and,
    tkn_or,
    tkn_not,
    tkn_null,
    tkn_neg,
    tkn_eq,
    tkn_ne,
    tkn_gt,
    tkn_ge,
    tkn_lt,
    tkn_le,
    tkn_between,
    tkn_escape,
    tkn_exists,
    tkn_like,
    tkn_limit,
    tkn_in,
    tkn_length,
    tkn_lower,
    tkn_upper,
    tkn_abs,
    tkn_area,
    tkn_is,
    tkn_integer,
    tkn_real,
    tkn_string,
    tkn_wstring,
    tkn_first,
    tkn_last,
    tkn_current,
    tkn_var,
    tkn_col,
    tkn_true,
    tkn_false,
    tkn_where,
    tkn_follow,
    tkn_start,
    tkn_from,
    tkn_order,
    tkn_overlaps,
    tkn_by,
    tkn_asc,
    tkn_desc,
    tkn_eof,
    tkn_insert,
    tkn_into,
    tkn_select,
    tkn_table,
    tkn_error,
    tkn_all,
    tkn_match,
    tkn_last_token
};

struct dbStrLiteral {
    char* str;
    int   len;
};

struct dbWStrLiteral {
    wchar_t* str;
    int      len;
};


class dbUserFunction;
class dbExprNodeSegment;

class FASTDB_DLL_ENTRY dbExprNodeAllocator {
  private:
    friend class dbExprNodeSegment;
    dbExprNode*        freeNodeList;
    dbExprNodeSegment* segmentList;
    dbMutex            mutex;

  public:
    dbMutex&    getMutex() {
        return mutex;
    }
    dbExprNode* allocate();
    void        deallocate(dbExprNode* node);
    void        reset();

    ~dbExprNodeAllocator();
    static dbExprNodeAllocator instance;
};

class FASTDB_DLL_ENTRY dbExprNode {
    friend class dbExprNodeSegment;
  public:
    nat1 cop;
    nat1 type;
    nat2 offs;

    static const nat1  nodeTypes[];
    static const nat1  nodeOperands[];
    static const nat1  commutativeOperator[];

    struct ref_operands {
        dbExprNode*         base;  // the same as operand[0]
        dbFieldDescriptor*  field;
    };

    struct func_operands {
        dbExprNode*         arg[3];
        void*               fptr;
    };

#ifdef USE_REGEX
    struct regex_operands {
        dbExprNode*         opd;
        regex_t             re;
    };
#endif

    union {
        dbExprNode*    operand[3];
        dbExprNode*    next;
        oid_t          oid;
        db_int8        ivalue;
        real8          fvalue;
        rectangle      rvalue;
        dbStrLiteral   svalue;
        dbWStrLiteral  wsvalue;
        void const*    var;
        ref_operands   ref;
        func_operands  func;
#ifdef USE_REGEX
        regex_operands regex;
#endif
    };

    dbExprNode(dbExprNode* node);

    dbExprNode(int cop, dbExprNode* left = NULL, dbExprNode* right = NULL,
               dbExprNode* right2 = NULL)
    {
        this->cop = cop;
        type = nodeTypes[cop];
        operand[0] = left;
        operand[1] = right;
        operand[2] = right2;
    }
    dbExprNode(int cop, dbExprNode* expr1, dbExprNode* expr2, int offs) {
        this->cop = cop;
        this->offs = (nat2)offs;
        type = nodeTypes[cop];
        operand[0] = expr1;
        operand[1] = expr2;
    }
    dbExprNode(int cop, dbExprNode* expr, int offs) {
        this->cop = cop;
        this->offs = (nat2)offs;
        type = nodeTypes[cop];
        operand[0] = expr;
    }
    dbExprNode(int cop, dbFieldDescriptor* field, dbExprNode* base = NULL)
    {
        this->cop = cop;
        this->offs = (nat2)field->dbsOffs;
        type = nodeTypes[cop];
        ref.field = field;
        ref.base = base;
    }
    dbExprNode(int cop, db_int8 ivalue) {
        this->cop = cop;
        this->ivalue = ivalue;
        type = tpInteger;
    }
    dbExprNode(int cop, real8 fvalue) {
        this->cop = cop;
        this->fvalue = fvalue;
        type = tpReal;
    }
    dbExprNode(int cop, rectangle rvalue) {
        this->cop = cop;
        this->rvalue = rvalue;
        type = tpRectangle;
    }
    dbExprNode(int cop, dbStrLiteral& svalue) {
        this->cop = cop;
        this->svalue = svalue;
        type = tpString;
    }
    dbExprNode(int cop, dbWStrLiteral& wsvalue) {
        this->cop = cop;
        this->wsvalue = wsvalue;
        type = tpWString;
    }
    dbExprNode(int cop, void const* var) {
        this->cop = cop;
        this->var = var;
        type = nodeTypes[cop];
    }
    dbExprNode(int cop, void* fptr, dbExprNode* expr1, dbExprNode* expr2 = NULL, dbExprNode* expr3 = NULL) {
        this->cop = cop;
        func.arg[0] = expr1;
        func.arg[1] = expr2;
        func.arg[2] = expr3;
        func.fptr = fptr;
        type = nodeTypes[cop];
    }
    ~dbExprNode();

    void* operator new(size_t size EXTRA_DEBUG_NEW_PARAMS) {
        return dbExprNodeAllocator::instance.allocate();
    }

    void operator delete(void* ptr EXTRA_DEBUG_NEW_PARAMS) {
        dbExprNodeAllocator::instance.deallocate((dbExprNode*)ptr);
    }
};


class dbExprNodeSegment {
  public:
    enum { allocationQuantum = 1024};
    char               buf[sizeof(dbExprNode)*allocationQuantum];
    dbExprNodeSegment* next;
};


class dbBinding {
  public:
    dbBinding*  next;
    char const* name;
    bool        used;
    int         index;
};

class dbOrderByNode {
  public:
    dbOrderByNode*     next;
    dbFieldDescriptor* field;
    dbTableDescriptor* table;
    dbExprNode*        expr;
    bool               ascent;  // true for ascent order, false for descent

    dbFieldDescriptor* getField() {
        return (field != NULL) ? field
            : ((unsigned)expr->cop - dbvmLoadBool <= dbvmLoadRawBinary - dbvmLoadBool)
               ? expr->ref.field : NULL;
    }

    ~dbOrderByNode() {
        delete expr;
    }
};

class dbFollowByNode {
  public:
    dbFollowByNode*    next;
    dbFieldDescriptor* field;
};

class FASTDB_DLL_ENTRY dbCompiler {
    friend class dbQuery;
    friend class dbQueryElement;
  public:
    enum {
        maxSymbolLen    = 4096,
        maxFreeVars  = 4
    };

    dbTableDescriptor* table;
    dbQueryElement*    queryElement;
    int                currPos;
    int                firstPos;
    int                offsetWithinStatement;
    int                bvalue;
    db_int8            ivalue;
    real8              fvalue;
    dbStrLiteral       svalue;
    dbWStrLiteral      wsvalue;
    bool               hasToken;
    int                lex;
    char*              name;
    dbBinding*         bindings;
    int                nFreeVars;
    int                varType;
    void const*        varPtr;
    dbTableDescriptor* varRefTable;

    jmp_buf            abortCompilation;
    static bool        initialized;

    void        compare(dbExprNode* expr, dbExprNode* list);

    int         scan();
    void        ungetToken(int tkn) {
        lex = tkn;
        hasToken = true;
    }
    void        error(const char* msg, int pos = -1);
    dbExprNode* conjunction();
    dbExprNode* disjunction();
    dbExprNode* comparison();
    dbExprNode* addition();
    dbExprNode* multiplication();
    dbExprNode* power();
    dbExprNode* term();
    dbExprNode* buildList();
    dbExprNode* userDefinedOperator();
    dbExprNode* field(dbExprNode* expr, dbTableDescriptor* refTable,
                      dbFieldDescriptor* fd);

    bool        compile(dbTableDescriptor* table, dbQuery& query);
    dbExprNode* compileExpression(dbTableDescriptor* table,  char const* expr, int startPos);
    void        compileOrderByPart(dbQuery& query);
    void        compileLimitPart(dbQuery& query);
    void        compileStartFollowPart(dbQuery& query);

    void        deleteNode(dbExprNode* node);
    dbExprNode* rectangleConstant(dbExprNode* head);

    dbCompiler();
};

class dbDatabaseThreadContext : public dbL2List {
  public:
    int readAccess;
    int writeAccess;
    int concurrentId;
    int mutatorCSLocked;
    int isMutator;

    dbL2List cursors;

    dbCompiler compiler;

    dbProcessId currPid;

    bool     interactive;
    bool     catched;
    bool     commitDelayed;
    bool     removeContext;
    jmp_buf  unwind;

    dbDatabaseThreadContext() {
        concurrentId = 0;
        readAccess = false;
        writeAccess = false;
        mutatorCSLocked = false;
        isMutator = false;
        interactive = false;
        catched = false;
        commitDelayed = false;
        removeContext = false;
        currPid = dbProcessId::getCurrent();
    }
};

union dbSynthesizedAttribute {
    byte*     base;
    int       bvalue;
    db_int8   ivalue;
    real8     fvalue;
    rectangle rvalue;
    void*     raw;
    oid_t     oid;

    struct {
        char* base;
        int   size;
        dbUDTComparator comparator;
    } array;
};

struct dbStringValue;

struct FASTDB_DLL_ENTRY dbInheritedAttribute {
    byte*          record;
    oid_t          oid;
    dbTable*       table;
    dbDatabase*    db;
    dbStringValue* tempStrings;
    size_t         paramBase;
    enum {
        internalStrBufSize = 8*1024
    };
    size_t         strBufPos;
    char           strBuf[internalStrBufSize];

    struct {
        int     index;
        jmp_buf unwind;
    } exists_iterator[dbCompiler::maxFreeVars];

    void removeTemporaries();

    dbInheritedAttribute() {
        tempStrings = NULL;
        strBufPos = 0;
    }

    ~dbInheritedAttribute() {
        removeTemporaries();
    }
};

struct dbStringValue {
    dbStringValue* next;
    char           str[1];

    static char* create(size_t size, dbInheritedAttribute& attr) {
        if (attr.strBufPos + size > sizeof(attr.strBuf)) {
            dbStringValue* sv =
                (dbStringValue*)new char[offsetof(dbStringValue, str) + size];
            sv->next = attr.tempStrings;
            attr.tempStrings = sv;
            return sv->str;
        } else {
            char* p = attr.strBuf + attr.strBufPos;
            attr.strBufPos += size;
            return p;
        }
    }

    static char* create(char const* s, dbInheritedAttribute& attr) {
        size_t len = strlen(s) + 1;
        char*  buf;
        if (attr.strBufPos + len > sizeof(attr.strBuf)) {
            dbStringValue* sv =
                (dbStringValue*)new char[offsetof(dbStringValue,str)+len];
            sv->next = attr.tempStrings;
            attr.tempStrings = sv;
            buf = sv->str;
        } else {
            buf = attr.strBuf + attr.strBufPos;
            attr.strBufPos += len;
        }
        return strcpy(buf, s);
    }
};

inline char* findWildcard(char* pattern, char* escape = NULL)
{
    if (escape == NULL) {
        while (*pattern != dbMatchAnyOneChar &&
               *pattern != dbMatchAnySubstring)
        {
            if (*pattern++ == '\0') {
                return NULL;
            }
        }
    } else {
        char esc = *escape;
        while (*pattern != dbMatchAnyOneChar &&
               *pattern != dbMatchAnySubstring &&
               *pattern != esc)
        {
            if (*pattern++ == '\0') {
                return NULL;
            }
        }
    }
    return pattern;
}

inline wchar_t* findWildcard(wchar_t* pattern, wchar_t* escape = NULL)
{
    if (escape == NULL) {
        while (*pattern != dbMatchAnyOneChar &&
               *pattern != dbMatchAnySubstring)
        {
            if (*pattern++ == '\0') {
                return NULL;
            }
        }
    } else {
        wchar_t esc = *escape;
        while (*pattern != dbMatchAnyOneChar &&
               *pattern != dbMatchAnySubstring &&
               *pattern != esc)
        {
            if (*pattern++ == '\0') {
                return NULL;
            }
        }
    }
    return pattern;
}

END_FASTDB_NAMESPACE

#endif