src/storage/CatalogTablesFk.cxx

   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 #include<CatalogTables.h>
  17 #include<Database.h>
  18 #include<Allocator.h>
  19 #include<Field.h>
  20 #include<Debug.h>
  21
  22 DbRetVal CatalogTableFK::insert(char *name, void *tptr, void *tPkptr)
  23 {
  24     Chunk *tChunk = systemDatabase_->getSystemDatabaseChunk(ForeignKeyTableId);
  25     ChunkIterator iter = tChunk->getIterator();
  26     void *data = NULL;
  27     while ((data = iter.nextElement())!= NULL)
  28     {
  29        if (0 == strcmp(((CFK*)data)->fkName_, name))
  30        {
  31           printError(ErrAlready, "Index with name \'%s\' already exists "
  32                           "on the table \'%s\'.", name, ((CTABLE *)tptr)->tblName_);
  33           return ErrAlready;
  34        }
  35     }
  36
  37     DbRetVal rv =OK;
  38     void *fkptr = tChunk->allocate(systemDatabase_, &rv);
  39     if (NULL == fkptr)
  40     {
  41         printError(rv, "Could not allocate for FK catalog table");
  42         return rv;
  43     }
  44     CFK *fkTblInfo = (CFK*)fkptr;
  45     strcpy(fkTblInfo->fkName_, name);
  46     fkTblInfo->fkTblPtr_= tptr;
  47     fkTblInfo->pkTblPtr_= tPkptr;
  48     printDebug(DM_SystemDatabase,"One Row inserted into FK %x %s",fkptr, name);
  49     return OK;
  50 }
  51
  52 DbRetVal CatalogTableFKFIELD::insert(char *cFKName, char **fkFldPtrs, char **pkFldPtrs,int totalFld)
  53 {
  54     Chunk *tChunk = NULL;
  55     tChunk = systemDatabase_->getSystemDatabaseChunk(ForeignKeyTableId);
  56     ChunkIterator iter = tChunk->getIterator();
  57     void *data = NULL;
  58     while ((data = iter.nextElement())!= NULL)
  59     {
  60        if (0 == strcmp(((CFK*)data)->fkName_, cFKName))
  61        {
  62             break;
  63        }
  64     }
  65     tChunk = systemDatabase_->getSystemDatabaseChunk(ForeignKeyFieldTableId);
  66     int i =0;
  67     DbRetVal rv = OK;
  68     while (i < totalFld)
  69     {
  70         void *fieldptr = tChunk->allocate(systemDatabase_, &rv);
  71         if (NULL == fieldptr)
  72         {
  73             printError(rv, "Could not allocate for USER catalog table");
  74             return rv;
  75         }
  76         CFKFIELD *fldInfo = (CFKFIELD*)fieldptr;
  77         fldInfo->fkPtr_ = data;
  78         fldInfo->pfFldPtr_ = (CFIELD*)pkFldPtrs[i];
  79         fldInfo->fkFldPtr_ = (CFIELD*)fkFldPtrs[i++];
  80         //printDebug(DM_TEST,"TYPE %d\n",((CFIELD*)fldInfo->pfFldPtr_)->type_);
  81         //printDebug(DM_TEST,"FK name %s\n",((CFIELD*)fldInfo->fkFldPtr_)->fldName_);
  82         if(!(((CFIELD*)fldInfo->pfFldPtr_)->isUnique_) || !(((CFIELD*)fldInfo->pfFldPtr_)->isNull_))
  83         {
  84              printError(ErrSysInternal,"Parent Table field should have  primary key field ");
  85              tChunk->free(systemDatabase_,fieldptr);
  86              return ErrSysInternal;
  87         }
  88         if(((CFIELD*)fldInfo->pfFldPtr_)->type_!=((CFIELD*)fldInfo->fkFldPtr_)->type_)
  89         {
  90            printError(ErrSysInternal,"Type Missmatch in both PK field and FK field  ");
  91            tChunk->free(systemDatabase_,fieldptr);
  92            return ErrSysInternal;
  93         }
  94         printDebug(DM_SystemDatabase,"One Row inserted into FKFIELD %x", fldInfo);
  95     }
  96     return OK;
  97 }
  98
  99 DbRetVal CatalogTableFK::remove(void *ctptr)
 100 {
 101     Chunk *tChunk = systemDatabase_->getSystemDatabaseChunk(ForeignKeyTableId);
 102     ChunkIterator iter = tChunk->getIterator();
 103     void *data = NULL;
 104     while ((data = iter.nextElement())!= NULL)
 105     {
 106         if (data == ctptr)
 107         {
 108             tChunk->free(systemDatabase_,data);
 109             printDebug(DM_SystemDatabase,"One Row deleted from FKFIELD %x", data);
 110         }
 111     }
 112     return OK;
 113 }
 114
 115 DbRetVal CatalogTableFKFIELD::remove(void *cFKfld)
 116 {
 117     Chunk *fChunk = NULL;
 118     fChunk = systemDatabase_->getSystemDatabaseChunk(ForeignKeyFieldTableId);
 119     ChunkIterator iter = fChunk->getIterator();
 120     void *data = NULL;
 121     while ((data = iter.nextElement())!= NULL)
 122     {
 123        if (((CFKFIELD*)data)->fkPtr_== cFKfld )
 124        {
 125           fChunk->free(systemDatabase_, data);
 126           printDebug(DM_SystemDatabase,"One Row deleted from CFKFIELD %x", data);
 127        }
 128     }
 129     return OK;
 130 }
 131
 132 void *CatalogTableFK::getFkCTable(void *ctptr)
 133 {
 134     Chunk *tChunk = systemDatabase_->getSystemDatabaseChunk(ForeignKeyTableId);
 135     ChunkIterator iter = tChunk->getIterator();
 136     void *data = NULL;
 137     while ((data = iter.nextElement())!= NULL)
 138     {
 139         if (((CFK*)data)->fkTblPtr_== ctptr)
 140         {
 141             return data;
 142         }
 143
 144     }
 145     return NULL;
 146 }
 147
 148 int CatalogTableFK::getNumFkTable(void *ctptr)
 149 {
 150     Chunk *tChunk = systemDatabase_->getSystemDatabaseChunk(ForeignKeyTableId);
 151     ChunkIterator iter = tChunk->getIterator();
 152     void *data = NULL;
 153     int count=0;
 154     while ((data = iter.nextElement())!= NULL)
 155     {
 156         if (((CFK*)data)->pkTblPtr_== ctptr)
 157         {
 158             count++;
 159         }
 160     }
 161     return count;
 162 }
 163
 164 bool CatalogTableFK::isFkTable(void *ctptr)
 165 {
 166     Chunk *tChunk = systemDatabase_->getSystemDatabaseChunk(ForeignKeyTableId);
 167     ChunkIterator iter = tChunk->getIterator();
 168     void *data = NULL;
 169     int count=0;
 170     while ((data = iter.nextElement())!= NULL)
 171     {
 172         if (((CFK*)data)->fkTblPtr_== ctptr)
 173         {
 174             return true;
 175         }
 176     }
 177     return false;
 178 }
 179
 180 int CatalogTableFK::getNoOfFkTable(void *ctptr)
 181 {
 182     Chunk *tChunk = systemDatabase_->getSystemDatabaseChunk(ForeignKeyTableId);
 183     ChunkIterator iter = tChunk->getIterator();
 184     void *data = NULL;
 185     int count=0;
 186     while ((data = iter.nextElement())!= NULL)
 187     {
 188         if (((CFK*)data)->pkTblPtr_== ctptr)
 189         {
 190             count++;
 191         }
 192     }
 193     return count;
 194 }
 195
 196 int CatalogTableFK::getNoOfPkTable(void *ctptr)
 197 {
 198     Chunk *tChunk = systemDatabase_->getSystemDatabaseChunk(ForeignKeyTableId);
 199     ChunkIterator iter = tChunk->getIterator();
 200     void *data = NULL;
 201     int count=0;
 202     while ((data = iter.nextElement())!= NULL)
 203     {
 204         if (((CFK*)data)->fkTblPtr_== ctptr)
 205         {
 206             count++;
 207         }
 208     }
 209     return count;
 210 }
 211
 212 void CatalogTableFK::getPkTableName(void *ctptr,char **&array)
 213 {
 214     Chunk *tChunk = systemDatabase_->getSystemDatabaseChunk(ForeignKeyTableId);
 215     ChunkIterator iter = tChunk->getIterator();
 216     void *data = NULL;
 217     int i=0;
 218     while ((data = iter.nextElement())!= NULL)
 219     {
 220             if (((CFK*)data)->fkTblPtr_== ctptr)
 221             {
 222                array[i++] = ((CTABLE*)((CFK*)data)->pkTblPtr_)->tblName_;
 223             }
 224     }
 225 }
 226
 227 void CatalogTableFK::getFkTableName(void *ctptr,char **&array)
 228 {
 229     Chunk *tChunk = systemDatabase_->getSystemDatabaseChunk(ForeignKeyTableId);
 230     ChunkIterator iter = tChunk->getIterator();
 231     void *data = NULL;
 232     int i=0;
 233     while ((data = iter.nextElement())!= NULL)
 234     {
 235             if (((CFK*)data)->pkTblPtr_== ctptr)
 236             {
 237                array[i++] = ((CTABLE*)((CFK*)data)->fkTblPtr_)->tblName_;
 238             }
 239     }
 240 }
 241
 242
 243 DbRetVal CatalogTableFK::getPkFkFieldInfo(void *cpkptr, void *cfkptr, FieldNameList &pklist,FieldNameList &fklist)
 244 {
 245     Chunk *tChunk = systemDatabase_->getSystemDatabaseChunk(ForeignKeyTableId);
 246     ChunkIterator iter = tChunk->getIterator();
 247     void *data = NULL;
 248     while ((data = iter.nextElement())!= NULL)
 249     {
 250         if (((CFK*)data)->pkTblPtr_== cpkptr && ((CFK*)data)->fkTblPtr_ == cfkptr)
 251         {
 252            break;
 253         }
 254     }
 255     if(data == NULL)
 256     {
 257         printError(ErrNotExists,"Foreign Key field CFK not found");
 258         return ErrNotExists;
 259     }
 260     Chunk *fChunk = systemDatabase_->getSystemDatabaseChunk(ForeignKeyFieldTableId);
 261     iter = fChunk->getIterator();
 262     void *fdata=NULL;
 263     while ((fdata = iter.nextElement())!= NULL)
 264     {
 265         if (((CFKFIELD*)fdata)->fkPtr_==data)
 266         {
 267             //printDebug(DM_TEST,"PK Field name %s\n",((CFIELD*)((CFKFIELD*)fdata)->pfFldPtr_)->fldName_);
 268             //printDebug(DM_TEST,"FK Field name %s\n",((CFIELD*)((CFKFIELD*)fdata)->fkFldPtr_)->fldName_);
 269             pklist.append(((CFIELD*)((CFKFIELD*)fdata)->pfFldPtr_)->fldName_);
 270             fklist.append(((CFIELD*)((CFKFIELD*)fdata)->fkFldPtr_)->fldName_);
 271         }
 272     }
 273     return OK;
 274 }
 275
 276