---

cProtoBase.h

Go to the documentation of this file.

/******************************************************************************/
/*                                                                            */
/* POLiTe - Persistent Object Library Test                                    */
/*                                        Ph.D. Thesis by Mgr. Michal Kopecky */
/*                                                                            */
/* Charles University Prague                                                  */
/*                                                                            */
/******************************************************************************/
/*                                                                            */
/* File name: ...                                                             */
/* Module: ......                                                             */
/*                                                                            */
/******************************************************************************/

#ifndef __C_PROTOBASE_H__
#define __C_PROTOBASE_H__

// Standard Header(s)
#include <stdio.h>
#include <malloc.h>
#include <fstream.h>

// Common POLiTe Header(s)
#include <lDefs.h>

// Parent Header(s)
#include <cQueRefProto.h>

class DLL_External ProtoBase : public QueRefProto
{
#ifdef POLITE_TEST_FRIEND
        friend POLITE_TEST_FRIEND;
#endif // POLITE_TEST_FRIEND

friend class RefBase;
friend class ClassRegister;
friend class Object;
friend class DatabaseObject;
friend class ObjectBuffer;
friend class ResultBase;
friend class ChainedRelationBase;

protected:
        static class ProtoBase *_root;
        // root of the search tree of all prototypes
        static class ProtoBase *_first;
        // first element of the list of all prototypes
        // having both tree and list reduces time
        // for searching prototypes and eliminate the recurse in some algorithms
        class ProtoBase *_left, *_right, *_next;
        bool _initialised;
        bool _processed;
        bool _isObject, _isImmutableObject, _isDatabaseObject, _isPersistentObject, _isRootClass;
        //Flags  that distinguish different families of objects
        //If isRootClass==true then it is one of four basic prototypes
        char *_condition;
        struct
        {
                int KeyCount;
                // Boundary of key members at the begining of the datatabase
                // keys keep positions 0..KeyCount-1
                int Count;
                // Count of botk key and non-key elements in the member database _sqlVars
                int SpecCount;
                // Boundary of additional columns
                // needed for virtualisation of resulted pointers
                // used only for Proto<PersistentObject>
                // which selects also Class Name in addition to OID
                void *Arr;
        } _sqlVars;
        // Pointer to the database of member attributes
        // Array of structures, defined in the class implementation
        class ProtoBase *_rootPrototype;
        // determines if the object is derived from
        // Object, ImmutableObject, Object or DatabaseObject
        int _parentPrototypeCount;
        // Number of direct predecessors
        class ProtoBase **_parentPrototype;
        // Array of direct predecessors
        int _fullParentPrototypeCount;
        // Number of all predecessors including this class
        class ProtoBase **_fullParentPrototype;
        // Array of all predecessors
        char *_select;
        char *_fullSelect;
        char *_keySelect;
        char *_ptrSelect;
        char *_into;
        //char *_fullInto;
        //char *_keyInto;
        char *_fullFrom;
        char *_where;
        char *_fullWhere;
        char *_keyWhere;
        char *_groupBy;
        char *_having;
        char *_stmtSelect;
        char *_stmtInsert;
        char *_stmtDelete;
        char *_stmtUpdate;
        static void _ResetProcessed(ProtoBase * const _p);
        virtual bool _KeyValues(char *&s);
        virtual char * _KeyValues(const class Object &o);
        //methods return comma-separated list of encoded values of key attributes
        virtual bool _ExportAttributes(const class Object &o);
        //method copies attributes of an object into prototype's buffers
        virtual bool _ExportKeyAttributes(const class Object &o);
        //method copies only key attributes of an object into prototype's buffers
        virtual bool _ExportKeyAttributes(const class RefBase &x);
        //method copies key attributes from reference into prototype's buffers
        virtual bool _ImportAttributes(class Object &o);
        //method copies attributes of an object from prototype's buffers
        virtual bool _ImportKeyAttributes(class RefBase &x);
        //method copies key attributes of an object from prototype's buffers into reference
        void _Initialise();
        void _InitialiseParentPrototype();
        void _InitialiseFullParentPrototype(class ProtoBase *_p);
        void _InitialiseSqlVar();
        void _InitialiseSelect();
        void _InitialiseFullSelect();
        void _InitialiseKeySelect();
        void _InitialisePtrSelect();
        void _InitialiseInto();
        //void _InitialiseFullInto();
        //void _InitialiseKeyInto();
        void _InitialiseFullFrom();
        void _InitialiseWhere();
        void _InitialiseFullWhere();
        void _InitialiseKeyWhere();
        void _InitialiseGroupBy();
        void _InitialiseHaving();
        void _InitialiseStmtSelect();
        void _InitialiseStmtInsert();
        void _InitialiseStmtDelete();
        void _InitialiseStmtUpdate();

        char * _StmtSelectPtr(
        // Method creates a SQL SELECT command
        // that selects only primary key
        // plus special columns like ClassName
        // and adds additional condition.
        // Wanted result :
        // SELECT - FROM - WHERE - GROUP BY - HAVING - ORDER BY
                const QueRefProto &Q,
                const int i
                );

        char * _StmtSelectPtr(
        // Method creates a SQL SELECT command
        // that selects only primary key
        // plus special columns like ClassName
        // and adds additional condition.
        // Wanted result :
                const char *const _where_clause,
                const char *const _order_by_clause,
                const char *const _select_clause,
                const char *const _from_clause,
                const int i
                );

        bool _BindPtr(
        // Method binds all columns of _StmtSelectPtr's statement
                class Cursor *C
                );

        ProtoBase *_PtrPrototype();
        // Method returns last fetched class name for PersistentObject descendants

public:
        virtual char* _Where() const {return StrCpy(_condition);};
        virtual char* _OrderBy() const {return StrCpy(OrderBy());};
        static void Register(class ProtoBase *_p, const char * const _n);
        //static void ResetProcessed() {_ResetProcessed(_root);};
        static class ProtoBase *Find(const char * const _n);
        virtual class ResultBase * ExecuteQuery(
                const QueRefProto &Q,
                class Connection *DbCon,
                const int i,
                class ResultBase * QR
                );
        bool operator==(class ProtoBase &_p) {return (this == &_p);};
        bool operator!=(class ProtoBase &_p) {return (this != &_p);};
        bool operator<(class ProtoBase &_p);
        bool operator>(class ProtoBase &_p) {return (_p < *this);};
        bool operator<=(class ProtoBase &_p) {return ((this == &_p) || (*this < _p));};
        bool operator>=(class ProtoBase &_p) {return ((this == &_p) || (_p < *this));};
        ProtoBase() :
                _left(NULL),
                _right(NULL),
                _next(NULL),
                _initialised(false),
                _processed(false),
                _isObject(false),
                _isImmutableObject(false),
                _isDatabaseObject(false),
                _isPersistentObject(false),
                _isRootClass(false),
                _condition(NULL),
                _rootPrototype(NULL),
                _parentPrototypeCount(0),
                _parentPrototype(NULL),
                _fullParentPrototypeCount(0),
                _fullParentPrototype(NULL),
                _select(NULL),
                _fullSelect(NULL),
                _keySelect(NULL),
                _ptrSelect(NULL),
                _into(NULL),
                //_fullInto(NULL),
                //_keyInto(NULL),
                _fullFrom(NULL),
                _where(NULL),
                _fullWhere(NULL),
                _keyWhere(NULL),
                _stmtSelect(NULL),
                _stmtInsert(NULL),
                _stmtDelete(NULL),
                _stmtUpdate(NULL)
        {
                _sqlVars.KeyCount = 0;
                _sqlVars.Count = 0;
                _sqlVars.Arr = NULL;
        };
        ~ProtoBase();
        virtual bool IsObject() {_Initialise(); return _isObject;};
        virtual bool IsImmutableObject() {_Initialise(); return _isImmutableObject;};
        virtual bool IsDatabaseObject() {_Initialise(); return _isDatabaseObject;};
        virtual bool IsPersistentObject() {_Initialise(); return _isPersistentObject;};
        virtual const char* ClassName() = 0;
        virtual const char* BaseClassName() {return NULL;};
        virtual const char* RootClassName() = 0;
        virtual const char* ParentClassNames() = 0;
        virtual const char* Select() {_Initialise(); return _select;};
        virtual const char* Into() {_Initialise(); return _into;};
        virtual const char* From() = 0;
        virtual const char* Where() {_Initialise(); return _where;};
        virtual const char* GroupBy() {_Initialise(); return _groupBy;};
        virtual const char* Having() {_Initialise(); return _having;};
        virtual const char* OrderBy() const = 0;
        virtual const char* FullSelect() {_Initialise(); return _fullSelect;};
        virtual const char* FullFrom() {_Initialise(); return _fullFrom;};
        virtual char* FullFrom(int k);
        virtual const char* FullWhere() {_Initialise(); return _fullWhere;};
        virtual char* FullWhere(int k);
        virtual const char* KeySelect() {_Initialise(); return _keySelect;};
        //virtual const char* KeyInto() {_Initialise(); return _keyInto;};
        virtual const char* KeyWhere() {_Initialise(); return _keyWhere;};
        //virtual const char* FullInto() {_Initialise(); return _fullInto;};
        virtual const char* KeyFrom() {return _rootPrototype->From();};
        virtual class ProtoBase * RootPrototype() const {return _rootPrototype;};
        virtual int ParentPrototypeCount() {_Initialise(); return _parentPrototypeCount;};
        virtual class ProtoBase * ParentPrototype(const int i);
        virtual int FullParentPrototypeCount() {_Initialise(); return _fullParentPrototypeCount;};
        virtual class ProtoBase * FullParentPrototype(const int i);
        virtual class Object *New() const = 0;
        //Constructs a new empty transient variant of a corresponding persistent object type
        virtual class RefBase *NewRef() = 0;
        //Constructs a new empty reference to corresponding type
        //
        // Follows methods needed for translation Object syntax <-> SQL syntax
        //
        const char* ColumnTable(const char* const col);
        // Returns a table name containing the given column

protected:
        virtual char *_RealiasT(
                char * &fragment,
                const char *table,
                const int i,
                const int j
                );
        // replaces all occurences of table. with proper alias T$i_j
        virtual char *_RealiasT(
                char * &fragment,
                const int i
                );
        // replaces all occurences of all tables. with proper alias T$i_j
        virtual void _MapKey(int i, const char *&attr, unsigned char Object::*&mem, const char *&col, char &type, unsigned int &len, bool &rw) = 0;
        virtual void _Map(int i, const char *&attr, unsigned char Object::*&mem, const char *&col, char &type, unsigned int &len, bool &rw) = 0;
        virtual const char *_ProtoTWhere() = 0;
        virtual const char *_ProtoTGroupBy() = 0;
        virtual const char *_ProtoTHaving() = 0;
        bool _InsertAll(class Object *target);
        //Inserts complete instance
        bool _Insert(class Connection *aDbConn);
        //Inserts piece of an instance
        bool _UpdateAll(class Object *target);
        //Writes complete object from the memory to the database.
        bool _Update(class Connection *aDbConn);
        //Writes piece of an object from the memory to the database
        bool _DeleteAll(class RefBase *target);
        //Deletes an object from the database.
        bool _DeleteAll(class Object *target);
        //Deletes an object from the database.
        bool _Delete(class Connection * aDbConn);
        //Deletes piece of an object from the database.
        bool ProtoBase::_Load(
                class Object &o
                );
        //Loads one instance into memory

public:
        // Method lock a table assigned to target class in desired mode
        // the method works for really persistent objects
        bool ProtoBase::LockTable(
                class Connection *aDbCon,
                enum LockingStrategy aLockingStrategy = LS_Default,
                enum WaitingStrategy aWaitingStrategy = WS_Default
                );

        bool WriteDDL(ofstream &S, class Database &Db);
        // generates DDL stements nedded for the library to run
        char *ProtoBase::ColumnTypeDDL(int i, class Database &Db);
        // returns correct database column type for i-th attribute

protected:
        char *_TranslateToSql(char * (&dst), const char * const src);
        char *_TranslateToSql(char * (&src));
        // replaces C++ operator and names by relational ones
        class Query &_TranslateToSql(class Query &Q);
        // replaces C++ operators in both where and oreder-by part
        ProtoBase *_gcs(ProtoBase &X);
        // greatest common successor of *this and X
        // (one of potentially many of them)
};


#endif //__GC__PROTOBASE_H__

---