include/Info.h

   1 /***************************************************************************
   2  *                                                                         *
   3  *    Copyright (C) Lakshya Solutions Ltd. All rights reserved.            *
   4  *                                                                         *
   5  ***************************************************************************/
   6
   7 #ifndef INFO_H
   8 #define INFO_H
   9 #include<ErrorType.h>
  10 #include<DataType.h>
  11 #include<Field.h>
  12
  13 #ifndef AGGTYPE
  14 enum AggType
  15 {
  16     AGG_MIN = 1,
  17     AGG_MAX,
  18     AGG_SUM,
  19     AGG_AVG,
  20     AGG_COUNT,
  21     AGG_UNKNOWN
  22 };
  23 #define AGGTYPE
  24 #endif
  25
  26 struct IndexInfoForDriver
  27 {
  28     char tableName[IDENTIFIER_LENGTH];
  29     char fieldName[IDENTIFIER_LENGTH];
  30     char indexName[IDENTIFIER_LENGTH];
  31     int type;
  32     int position;
  33     int pageUsed;
  34     bool isUnique;
  35     bool isPrimary;
  36 };
  37
  38 class DataTypeInfo
  39 {
  40     public:
  41     char name[IDENTIFIER_LENGTH];
  42     int type;
  43     int precision;
  44     bool autoIncrement;
  45 };
  46
  47 class ForeignKeyMetadata
  48 {
  49     public:
  50     char pkTableName[IDENTIFIER_LENGTH];
  51     char pkColName[IDENTIFIER_LENGTH];
  52     char fkTableName[IDENTIFIER_LENGTH];
  53     char fkColName[IDENTIFIER_LENGTH];
  54     short keySeq;
  55     short updateRule;
  56     short deleteRule;
  57 };
  58
  59 enum ResultSetPlan
  60 {
  61     Normal = 0,
  62     GetTables,
  63     GetColumns,
  64     GetIndexes,
  65     GetPriIndex,
  66     GetCatalogs,
  67     GetTableType,
  68     GetDataType,
  69     GetImportKey,
  70     GetExportKey
  71 };
  72
  73 class FieldNameNode;
  74
  75 /**
  76 * @class FieldNameList
  77 *
  78 * @brief Field name list used to specify composite key while creating index. <br/>
  79 *
  80 */
  81 class DllExport FieldNameList
  82 {
  83     FieldNameNode *head;
  84     FieldNameNode *iter;
  85     public:
  86     FieldNameList() { head = iter = NULL; }
  87     ~FieldNameList() { } //TODO::Remove all elements from the list
  88     char *nextFieldName();
  89     void resetIter(){ iter = head; }
  90     int size();
  91
  92     /** appends field name to the list
  93     *   @param name field name
  94     *   @return int
  95     */
  96     DbRetVal append(const char *name);
  97
  98     /** removes field name from the list
  99     *   @param name field name
 100     *   @return int
 101     */
 102     DbRetVal remove(const char *name);
 103     DbRetVal removeAll();
 104 };
 105
 106 class FieldList;
 107 class FieldIterator;
 108
 109
 110 /**
 111 * @class TableDef
 112 *
 113 * @brief Represents table definition used to create the table.
 114 * Encapsulates the information or schema definition of a table.For Example say if <br/>
 115 * we need to create table with two fields, call addField method with necessary parameters<br/>
 116 * twice. Passed as argument to createTable method of DatabaseManager to create table.<br/>
 117 *
 118 */
 119 class DllExport TableDef
 120 {
 121     private:
 122     FieldList fldList;
 123     int fldCount;
 124     public:
 125     TableDef() { fldCount = 0; }
 126     ~TableDef();
 127     void reset();
 128     /** adds a field to the schema definition.
 129     *   @param name field name
 130     *   @param type data type of the field
 131     *   @param length size of the field. used in case of char and binary data types.
 132     *   @param defaultValue default value for the field. It is currently limited to 32 bytes.
 133     *   @param isPrimary whether the field is primary key( not null + unique)
 134     *   @param notNull whether the field can be null
 135     *   @param unique whether the field values are unique
 136     *   @return int
 137     */
 138     int addField(const char *name,  DataType type = typeUnknown, size_t
 139                  length = 0, const void *defaultValue = 0,
 140                  bool notNull = false, bool autoIn = false);
 141
 142     /** removes a field from the schema definition
 143     *   @param name field name
 144     *   @return int
 145     */
 146     int dropField(const char *name);
 147
 148     /** returns the total number of fields in this table definition
 149     *   @return int no of fields
 150     */
 151     int getFieldCount();
 152
 153     /** returns the total tuple size in bytes.
 154     *   @return size_t tuple size
 155     */
 156     size_t getTupleSize();
 157
 158     //Internal method used to iterate and get information stored
 159     //in this table definition.
 160     FieldIterator getFieldIterator(){ return fldList.getIterator(); }
 161     bool isVarcharPresentInSchema(FieldIterator &iter);
 162 };
 163
 164 class DllExport FieldInfo
 165 {
 166     public:
 167     char fldName[IDENTIFIER_LENGTH];
 168     DataType type;
 169     size_t length;
 170     size_t offset;
 171     char defaultValueBuf[DEFAULT_VALUE_BUF_LENGTH];
 172     AggType aType;
 173     bool isNull;
 174     bool isPrimary;
 175     bool isDefault;
 176     bool isUnique;
 177     bool isAutoIncrement;
 178     FieldInfo()
 179     {
 180         fldName[0] = '\0'; type = typeUnknown; length = 0; offset = 0;
 181         defaultValueBuf[0]='\0'; aType = AGG_UNKNOWN; isNull = false;
 182         isPrimary = isDefault = isUnique = isAutoIncrement = false;
 183     }
 184 };
 185
 186
 187
 188 /** A Enum value
 189 */
 190 enum IndexType
 191 {
 192     hashIndex = 0, /**<hash index*/
 193     treeIndex,      /**<tree index*/
 194     trieIndex,      /**<trie index*/
 195     unknownIndex      /**<no index*/
 196 };
 197
 198 /**
 199 * @class IndexInitInfo
 200 *
 201 * @brief Represents index definition used to create index.
 202 * Encapsulates the information or definition of an index.<br/>
 203 *
 204 */
 205 class IndexInitInfo
 206 {
 207     public:
 208     char tableName[IDENTIFIER_LENGTH]; /**<tablename*/
 209     FieldNameList list;               /**<field name list*/
 210     IndexType indType;                /**<index type*/
 211     bool isUnique;                    /**<unique values*/
 212     bool isPrimary;                   /**<primary key*/
 213     IndexInitInfo() {  indType = hashIndex;  isUnique = false; isPrimary= false;}
 214     ~IndexInitInfo() {list.removeAll();}
 215 };
 216
 217 /**
 218 * @class HashIndexInitInfo
 219 *
 220 * @brief Represents hash index definition used to create index.
 221 * Encapsulates the information or definition of hash index.<br/>
 222 *
 223 */
 224 class HashIndexInitInfo : public IndexInitInfo
 225 {
 226     public:
 227     int bucketSize; /**<bucket size*/
 228     HashIndexInitInfo() { bucketSize = 1009; }
 229 };
 230
 231 class ForeignKeyInfo
 232 {
 233     public:
 234     ForeignKeyInfo(){}
 235     char pkTableName[IDENTIFIER_LENGTH];
 236     char fkTableName[IDENTIFIER_LENGTH];
 237     FieldNameList fkFldList;
 238     FieldNameList pkFldList;
 239 };
 240 #endif