include/Table.h

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by www.databasecache.com                           *
   3  *   Contact: praba_tuty@databasecache.com                                 *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15   ***************************************************************************/
  16 #ifndef TABLE_H
  17 #define TABLE_H
  18 #include<ErrorType.h>
  19 #include<Util.h>
  20 #include<DataType.h>
  21 class Predicate;
  22 class Condition;
  23 #ifndef SCANTYPE
  24 enum ScanType
  25 {
  26     fullTableScan = 0,
  27     hashIndexScan,
  28     treeIndexScan,
  29     trieIndexScan,
  30     unknownScan
  31 };
  32 #define SCANTYPE
  33 #endif
  34 /**
  35 * @class Table
  36 *
  37 * @brief Handle to the database table.
  38 * Table is a set of data values organized using a model of horizontal rows and columns.<br>
  39 * Columns are identified by name and rows by values. It shall be visualized as a linked <br/>
  40 * list of related data<br/>
  41 * Functionality: <br/>
  42 *     1.insert <br/>
  43 *     2.update <br/>
  44 *     3.delete <br/>
  45 *     4.select with predicate or condition<br/>
  46 * <br/>
  47 *
  48 */
  49
  50 class FieldInfo;
  51 class DllExport Table
  52 {
  53     public:
  54     /** sets condition for the select, update and delete operations
  55     *   @param c condition
  56     */
  57     virtual void setCondition(Condition *c)=0;
  58
  59     /** binds application buffer to the specified field of the table.
  60     * Before doing any DML operations required fields are binded first.
  61     * Below are the candidates for this: <br/>
  62     * 1.All the fields in the projection list of select statement. <br/>
  63     * 2.Field list in the insert statement.<br/>
  64     * 3.Fields in the assignment list of update statement.<br/>
  65     * <br/>
  66     *   @param name field name in the table
  67     *   @param val  address of the application buffer. Memory should be allocated by
  68     *               the application before binding the buffer.
  69     */
  70
  71     virtual DbRetVal bindFld(const char *name, void *val,
  72                                                      bool isNullExpl=false)=0;
  73     /** marks the specified field to insert null when insert method is called.
  74     *   @param name field name in the table
  75     */
  76     virtual void *getBindFldAddr(const char *name)=0;
  77     virtual DbRetVal markFldNull(const char *name)=0;
  78     /** marks the specified field to insert null when insert method is called.
  79     *   @param colpos field position
  80     */
  81     virtual DbRetVal markFldNull(int colpos)=0;
  82
  83     /** clears the null mark which is set before.
  84     *   @param name field name
  85     */
  86     virtual void clearFldNull(const char *name)=0;
  87
  88     /** clears the null mark which is set before.
  89     *   @param colpos field position
  90     */
  91     virtual void clearFldNull(int colpos)=0;
  92
  93     /** checks whether the field value is null.
  94     *   @param name field name
  95     */
  96     virtual bool isFldNull(const char *name)=0;
  97
  98     /** checks whether the field value is null for the specified field position.
  99     *   @param colpos field position
 100     */
 101     virtual bool isFldNull(int colpos)=0;
 102 /*
 103     virtual void clearFldNull(const char *name)=0;
 104     virtual void clearFldNull(int colpos) =0;
 105 */
 106
 107     //DML operations
 108     /** executes the select statement. Based on the predicate(condition), respective index is
 109     * chosen for the select. Application should call execute before they start fetching
 110     * the values from the table.This starts scan on the table.
 111     * @returns DbRetVal
 112     */
 113     virtual DbRetVal execute()=0;
 114
 115     /** insert the tuple into the table. Prior to this, the binded buffer should be updated
 116     *  Values present in the binded buffers of all the fields are taken and stored in
 117     *  the table.<br/>
 118     * @returns DbRetVal
 119     */
 120     virtual DbRetVal insertTuple()=0;
 121
 122     /**update values in the current tuple of the table. It works only on top of select
 123     *  using fetch go to the tuple to be updated, then update the binded buffer value and
 124     *  then call this method to updates the field values in the tuple.
 125     * @returns DbRetVal
 126     */
 127     virtual DbRetVal updateTuple()=0;
 128
 129     /**deletes the current tuple of the table. It works only on top of select.
 130     *  using fetch first go to the tuple to be deleted, then call this method to delete.<br/>
 131     *  To delete all the tuples, do not set any condition and call fetch followed by delete
 132     *  in a loop till fetch exhausts.
 133     * @returns DbRetVal
 134     */
 135
 136     virtual DbRetVal deleteTuple()=0;
 137
 138
 139     /**deletes all the records which satisfies the condition set.
 140     * @returns int totalTuples deleted
 141     */
 142
 143     virtual int deleteWhere()=0;
 144
 145
 146
 147     /**deletes the all the records in the table. No transaction required to call this.
 148     *  It takes table level lock.
 149     * @returns DbRetVal
 150     */
 151
 152     virtual int truncate()=0;
 153
 154     //scan
 155
 156     /**fetches the next tuple in the table which satisfies the condition specified.
 157     * execute should be called before calling this method. Application buffer should be
 158     * binded to get the tuple values.
 159     * @returns void* NULL if there is no tuple.
 160     */
 161     virtual void* fetch()=0;
 162     virtual void* fetch(DbRetVal &rv)=0;
 163
 164     /**fetches the next tuple in the table which satisfies the condition specified.
 165     * execute should be called before calling this method. Application buffer need not be
 166     * binded to call this method.
 167     * @returns void* NULL if there is no tuple.
 168     */
 169     virtual void* fetchNoBind()=0;
 170     virtual void* fetchNoBind(DbRetVal &rv)=0;
 171
 172
 173     /**closes the scan. Needs to be called before calling execute again on the same table handle. It releases the resources
 174  acquired during the scan.
 175     * @returns DbRetVal
 176     */
 177
 178     virtual DbRetVal close()=0;
 179     virtual DbRetVal closeScan()=0;
 180
 181     /**Retrieves the total space used for this table in bytes
 182     * @returns DbRetVal
 183     */
 184     virtual long spaceUsed()=0;
 185
 186     /**Retrieves the total number of tuples present in this table
 187     * @returns DbRetVal
 188     */
 189     virtual long numTuples()=0;
 190
 191     /**takes lock on the table
 192     * if bool shared flag is set, it will take shared lock, or else exclusive lock
 193     * @returns DbRetVal
 194     */
 195     virtual DbRetVal lock(bool shared)=0;
 196
 197     /**releases the lock acquired on the table
 198     * @returns DbRetVal
 199     */
 200     virtual DbRetVal unlock()=0;
 201
 202     /**sets the undo log flag. If this flag is unset then undo logs will not be generated
 203     * @returns DbRetVal
 204     */
 205     virtual DbRetVal setUndoLogging(bool flag)=0;
 206
 207     virtual DbRetVal getFieldInfo(const char *fieldName, FieldInfo *&info)=0;
 208     virtual List getFieldNameList()=0;
 209     virtual char* getName()=0;
 210     virtual char* getAliasName()=0;
 211     virtual void printSQLIndexString(FILE *fp=NULL, int fd=-1)=0;
 212     virtual void printSQLForeignString()=0;
 213     virtual DbRetVal compact()=0;
 214     //optimizer
 215     virtual DbRetVal optimize()=0;
 216     virtual ScanType getScanType()=0;
 217     virtual bool hasIndex(char *name)=0;
 218     virtual bool isTableInvolved(char *tblName)=0;
 219     virtual bool pushPredicate(Predicate *pred)=0;
 220     virtual void setPredicate(Predicate *pred)=0;
 221     virtual void printPlan(int space)=0;
 222     virtual void addPredicate(char *fname, ComparisionOp op, void *buf)
 223                  { return; }
 224     virtual bool isFKTable()=0;
 225     virtual void resetNullinfo()=0;
 226     virtual int getFldPos(char *name)=0;
 227     virtual ~Table() { }
 228
 229     virtual void setLoading(bool flag){};
 230
 231     //non virtual functions
 232     static void getFieldNameAlone(char *fname, char *name);
 233     static void getTableNameAlone(char *fname, char *name);
 234 };
 235
 236 #endif