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, DataStructures::Table::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