DS_Table.h

Go to the documentation of this file.

#ifndef __TABLE_H
#define __TABLE_H

#ifdef _MSC_VER
#pragma warning( push )
#endif

#include "DS_List.h"
#include "DS_BPlusTree.h"
#include "RakMemoryOverride.h"
#include "Export.h"
#include "RakString.h"

#define _TABLE_BPLUS_TREE_ORDER 16
#define _TABLE_MAX_COLUMN_NAME_LENGTH 64

namespace DataStructures
{

    class RAK_DLL_EXPORT Table
    {
    public:
            
        enum ColumnType
        {
            // Cell::i used
            NUMERIC,

            // Cell::c used to hold a null terminated string.
            STRING,

            // Cell::c holds data.  Cell::i holds data length of c in bytes.
            BINARY,

            // Cell::c holds data.  Not deallocated. Set manually by assigning ptr.
            POINTER,
        };
        
        
        // Note: If this structure is changed the struct in the swig files need to be changed as well
        struct RAK_DLL_EXPORT Cell
        {
            Cell();
            ~Cell();
            Cell(double numericValue, char *charValue, void *ptr, ColumnType type);
            void SetByType(double numericValue, char *charValue, void *ptr, ColumnType type);
            void Clear(void);
            
            void Set(int input);
            void Set(unsigned int input);
            void Set(double input);

            void Set(const char *input);

            void Set(const char *input, int inputLength);

            void SetPtr(void* p);

            void Get(int *output);
            void Get(double *output);

            void Get(char *output);

            void Get(char *output, int *outputLength);

            RakNet::RakString ToString(ColumnType columnType);

            // assignment operator and copy constructor
            Cell& operator = ( const Cell& input );
            Cell( const Cell & input);

            ColumnType EstimateColumnType(void) const;

            bool isEmpty;
            double i;
            char *c;
            void *ptr;
        };

        // Note: If this structure is changed the struct in the swig files need to be changed as well
        struct RAK_DLL_EXPORT ColumnDescriptor
        {
            ColumnDescriptor();
            ~ColumnDescriptor();
            ColumnDescriptor(const char cn[_TABLE_MAX_COLUMN_NAME_LENGTH],ColumnType ct);

            char columnName[_TABLE_MAX_COLUMN_NAME_LENGTH];
            ColumnType columnType;
        };

        // Note: If this structure is changed the struct in the swig files need to be changed as well
        struct RAK_DLL_EXPORT Row
        {
            // list of cells
            DataStructures::List<Cell*> cells;

            void UpdateCell(unsigned columnIndex, double value);

            void UpdateCell(unsigned columnIndex, const char *str);

            void UpdateCell(unsigned columnIndex, int byteLength, const char *data);
        };
        
        // Operations to perform for cell comparison
        enum FilterQueryType
        {
            QF_EQUAL,
            QF_NOT_EQUAL,
            QF_GREATER_THAN,
            QF_GREATER_THAN_EQ,
            QF_LESS_THAN,
            QF_LESS_THAN_EQ,
            QF_IS_EMPTY,
            QF_NOT_EMPTY,
        };

        // Compare the cell value for a row at columnName to the cellValue using operation.
        // Note: If this structure is changed the struct in the swig files need to be changed as well
        struct RAK_DLL_EXPORT FilterQuery
        {
            FilterQuery();
            ~FilterQuery();
            FilterQuery(unsigned column, Cell *cell, FilterQueryType op);

            // If columnName is specified, columnIndex will be looked up using it.
            char columnName[_TABLE_MAX_COLUMN_NAME_LENGTH];
            unsigned columnIndex;
            Cell *cellValue;
            FilterQueryType operation;
        };

        enum SortQueryType
        {
            QS_INCREASING_ORDER,
            QS_DECREASING_ORDER,
        };
        
        // Sort on increasing or decreasing order for a particular column
        // Note: If this structure is changed the struct in the swig files need to be changed as well
        struct RAK_DLL_EXPORT SortQuery
        {
            unsigned columnIndex;

            SortQueryType operation;
        };

        // Constructor
        Table();

        // Destructor
        ~Table();

        unsigned AddColumn(const char columnName[_TABLE_MAX_COLUMN_NAME_LENGTH], ColumnType columnType);

        void RemoveColumn(unsigned columnIndex);

        unsigned ColumnIndex(char columnName[_TABLE_MAX_COLUMN_NAME_LENGTH]) const;
        unsigned ColumnIndex(const char *columnName) const;

        char* ColumnName(unsigned index) const;

        ColumnType GetColumnType(unsigned index) const;

        unsigned GetColumnCount(void) const;

        unsigned GetRowCount(void) const;

        Table::Row* AddRow(unsigned rowId);
        Table::Row* AddRow(unsigned rowId, DataStructures::List<Cell> &initialCellValues);
        Table::Row* AddRow(unsigned rowId, DataStructures::List<Cell*> &initialCellValues, bool copyCells=false);

        bool RemoveRow(unsigned rowId);

        void RemoveRows(Table *tableContainingRowIDs);

        bool UpdateCell(unsigned rowId, unsigned columnIndex, int value);
        bool UpdateCell(unsigned rowId, unsigned columnIndex, char *str);
        bool UpdateCell(unsigned rowId, unsigned columnIndex, int byteLength, char *data);
        bool UpdateCellByIndex(unsigned rowIndex, unsigned columnIndex, int value);
        bool UpdateCellByIndex(unsigned rowIndex, unsigned columnIndex, char *str);
        bool UpdateCellByIndex(unsigned rowIndex, unsigned columnIndex, int byteLength, char *data);

        void GetCellValueByIndex(unsigned rowIndex, unsigned columnIndex, int *output);
        void GetCellValueByIndex(unsigned rowIndex, unsigned columnIndex, char *output);
        void GetCellValueByIndex(unsigned rowIndex, unsigned columnIndex, char *output, int *outputLength);

        Row* GetRowByID(unsigned rowId) const;

        Row* GetRowByIndex(unsigned rowIndex, unsigned *key) const;

        void QueryTable(unsigned *columnIndicesSubset, unsigned numColumnSubset, FilterQuery *inclusionFilters, unsigned numInclusionFilters, unsigned *rowIds, unsigned numRowIDs, Table *result);

        void SortTable(Table::SortQuery *sortQueries, unsigned numSortQueries, Table::Row** out);

        void Clear(void);

        void PrintColumnHeaders(char *out, int outLength, char columnDelineator) const;

        void PrintRow(char *out, int outLength, char columnDelineator, bool printDelineatorForBinary, Table::Row* inputRow) const;

        const DataStructures::List<ColumnDescriptor>& GetColumns(void) const;

        const DataStructures::BPlusTree<unsigned, Row*, _TABLE_BPLUS_TREE_ORDER>& GetRows(void) const;

        DataStructures::Page<unsigned, Row*, _TABLE_BPLUS_TREE_ORDER> * GetListHead(void);

        unsigned GetAvailableRowId(void) const;

        Table& operator = ( const Table& input );

    protected:
        Table::Row* AddRowColumns(unsigned rowId, Row *row, DataStructures::List<unsigned> columnIndices);

        void DeleteRow(Row *row);

        void QueryRow(DataStructures::List<unsigned> &inclusionFilterColumnIndices, DataStructures::List<unsigned> &columnIndicesToReturn, unsigned key, Table::Row* row, FilterQuery *inclusionFilters, Table *result);

        // 16 is arbitrary and is the order of the BPlus tree.  Higher orders are better for searching while lower orders are better for
        // Insertions and deletions.
        DataStructures::BPlusTree<unsigned, Row*, _TABLE_BPLUS_TREE_ORDER> rows;

        // Columns in the table.
        DataStructures::List<ColumnDescriptor> columns;
    };
}

#ifdef _MSC_VER
#pragma warning( pop )
#endif

#endif