src/sql/DdlStatement.cxx

   1 /***************************************************************************
   2  *   Copyright (C) 2007 by Prabakaran Thirumalai   *
   3  *   praba_tuty@yahoo.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 <os.h>
  17 #include <Statement.h>
  18 #include <Info.h>
  19 #ifndef MMDB
  20 #include <TableConfig.h>
  21 #endif
  22 CreateTblStatement::CreateTblStatement()
  23 {
  24     parsedData = NULL;
  25     dbMgr = NULL;
  26 }
  27
  28 CreateTblStatement::~CreateTblStatement()
  29 {
  30     tblDef.reset();
  31 }
  32 DbRetVal CreateTblStatement::execute(int &rowsAffected)
  33 {
  34     DbRetVal rv = OK;
  35     rv = dbMgr->createTable(tblName, tblDef);
  36     if (rv != OK) return rv;
  37     if (parsedData->getFieldNameList().size() > 0)
  38     {
  39         HashIndexInitInfo *idxInfo = new HashIndexInitInfo();
  40         strcpy(idxInfo->tableName, tblName);
  41         ListIterator iter = parsedData->getFieldNameList().getIterator();
  42         FieldName *name = NULL;
  43         while (iter.hasElement())
  44         {
  45             name = (FieldName*)iter.nextElement();
  46             idxInfo->list.append(name->fldName);
  47         }
  48         idxInfo->indType = hashIndex;
  49         idxInfo->isPrimary = true;
  50         idxInfo->isUnique = true;
  51         int bucket = parsedData->getBucketSize();
  52         if(bucket!=0)
  53             idxInfo->bucketSize = bucket;
  54         char indName[IDENTIFIER_LENGTH];
  55         sprintf(indName, "%s_idx1_Primary", tblName);
  56         rv = dbMgr->createIndex(indName, idxInfo);
  57         if (rv != OK)
  58         {
  59             dbMgr->dropTable(tblName);
  60             delete idxInfo;
  61             return rv;
  62         }
  63         delete idxInfo;
  64     }
  65     if(parsedData->getSecondaryIndexFieldList().size() > 0)
  66     {
  67         HashIndexInitInfo *idxInfo = new HashIndexInitInfo();
  68         strcpy(idxInfo->tableName, tblName);
  69         ListIterator iter = parsedData->getSecondaryIndexFieldList().getIterator();
  70         FieldInfo *name = NULL;
  71         while (iter.hasElement())
  72         {
  73             name = (FieldInfo*)iter.nextElement();
  74             idxInfo->list.append(name->fldName);
  75         }
  76         idxInfo->indType = treeIndex;
  77         idxInfo->isPrimary = true;
  78         idxInfo->isUnique = true;
  79         char indName[IDENTIFIER_LENGTH];
  80         sprintf(indName, "%s_idx_Auto_increment", tblName);
  81         rv = dbMgr->createIndex(indName, idxInfo);
  82         if (rv != OK)
  83         {
  84             dbMgr->dropTable(tblName);
  85             delete idxInfo;
  86             return rv;
  87         }
  88         delete idxInfo;
  89     }
  90     if(parsedData->getForeignKeyList().size() > 0)
  91     {
  92         ForeignKeyInfo *fkInfo=NULL;
  93         int i=0;
  94         ListIterator iter = parsedData->getForeignKeyList().getIterator();
  95         while (iter.hasElement())
  96         {
  97             fkInfo = (ForeignKeyInfo *)iter.nextElement();
  98             strcpy(fkInfo->fkTableName,tblName);
  99             char fkName[IDENTIFIER_LENGTH];
 100             sprintf(fkName, "%s_FKEY_%d", tblName,++i);
 101             rv = dbMgr->createForeignKey(fkName,fkInfo);
 102             if (rv != OK)
 103             {
 104                 dbMgr->dropTable(tblName);
 105                 return rv;
 106             }
 107         }
 108
 109     }
 110     return rv;
 111 }
 112 DbRetVal CreateTblStatement::checkForDot(char *name)
 113 {
 114     int i=0;
 115     while ( name[i] != '\0')
 116     {
 117         if (name[i++] == '.') { return ErrSyntaxError; }
 118     }
 119     return OK;
 120
 121 }
 122 DbRetVal CreateTblStatement::resolve()
 123 {
 124     DbRetVal rv = OK;
 125     strcpy(tblName, parsedData->getTableName());
 126     rv = checkForDot(tblName);
 127     if ( rv!=OK )
 128     {
 129           printf("Check SQL Syntax: .\n");
 130           return  rv;
 131     }
 132     FieldIterator iter = parsedData->getCreFldList().getIterator();
 133
 134     int i = 0;
 135     FieldName *name = NULL;
 136     ListIterator nIter = parsedData->getFieldNameList().getIterator();
 137     while (iter.hasElement())
 138     {
 139         FieldDef *fDef = iter.nextElement();
 140         nIter.reset();
 141         while (nIter.hasElement())
 142         {
 143             name = (FieldName*)nIter.nextElement();
 144             if (strcmp(name->fldName, fDef->fldName_) == 0) fDef->isNull_ = true;
 145         }
 146         rv = checkForDot(fDef->fldName_);
 147         if ( rv!=OK )
 148         {
 149             printf("Check SQL Syntax: .\n");
 150             return  rv;
 151         }
 152         /* To check char field and restrict it for the max length 8kb(8000)  */
 153         if( (fDef->type_ == 30) && (fDef->length_ > 8000) ){
 154             printError(ErrBadRange,"Char data type length should be less than 8kb(8000).");
 155             return ErrBadRange;
 156         }
 157         //TODO : need a new addField function which can take FieldDef as parameter.
 158        if (!fDef->isDefault_ || fDef->isDefault_ && fDef->defaultValueBuf_[0] == '\0')  {
 159            i = tblDef.addField(fDef->fldName_, fDef->type_, fDef->length_,
 160                         NULL,fDef->isNull_,fDef->isAutoIncrement_);
 161        } else {
 162            i = tblDef.addField(fDef->fldName_, fDef->type_, fDef->length_,
 163                         fDef->defaultValueBuf_,fDef->isNull_,fDef->isAutoIncrement_);
 164        }
 165        if( 0 != i )
 166        {
 167           printError(ErrUnknown, "Error while adding field");
 168           rv = ErrUnknown;
 169           break;
 170        }
 171     }
 172     return rv;
 173 }
 174 /////////////////////////////////////
 175 DbRetVal CacheTblStatement::resolve()
 176 {
 177     DbRetVal rv = OK;
 178 #ifndef MMDB
 179     TableConf::config.init();
 180     cacheLoader.setConnParam(I_USER, I_PASS);
 181     cacheLoader.setTable(parsedData->getTableName());
 182     TableConf::config.setTable(parsedData->getTableName());
 183     if(parsedData->getHCondFld()){
 184         cacheLoader.setCondition(parsedData->getHCondition());// new one
 185         TableConf::config.setCondition(parsedData->getHCondition());
 186     }
 187     if(parsedData->getVCondFld()) {
 188         cacheLoader.setFieldListVal(parsedData->getVCondition());
 189         TableConf::config.setFieldListVal(parsedData->getVCondition());
 190     }
 191     if(parsedData->getPkFld()){
 192         cacheLoader.setFieldName(parsedData->getIndexName());
 193         TableConf::config.setFieldName(parsedData->getIndexName());
 194     }
 195     if(parsedData->getDSN()){
 196         cacheLoader.setDsnName(parsedData->getPKTableName());
 197         TableConf::config.setDsnName(parsedData->getPKTableName());
 198     }
 199     if( !(parsedData->getUnCache()))
 200     {
 201         rv = TableConf::config.isTableCached(parsedData->getTableName());
 202         if(rv == OK){
 203            printError(ErrAlready, "Table is already cached,unload table then try");
 204            return ErrAlready;
 205         }
 206     }
 207 #endif
 208     return OK;
 209 }
 210 DbRetVal CacheTblStatement::execute(int &rowsAffected)
 211 {
 212     DbRetVal rv = OK;
 213 #ifndef MMDB
 214     if( parsedData->getUnCache())
 215     {
 216         unsigned int mode =
 217                     TableConf::config.getTableMode(parsedData->getTableName());
 218         bool isCached = TableConf::config.isTableCached(mode);
 219         if (!isCached) {
 220             printError(ErrNotCached, "Table is not Cached");
 221             return ErrNotCached;
 222         }
 223         TableConf::config.removeFromCacheTableFile();
 224     } else {
 225         rv = cacheLoader.load(!(parsedData->getNoSchema()));
 226         if(rv == OK){
 227             TableConf::config.addToCacheTableFile(parsedData->getDirect());
 228         } else return rv;
 229     }
 230 #endif
 231     return OK;
 232 }
 233 ///////////////////////////////////////
 234 CreateIdxStatement::CreateIdxStatement()
 235 {
 236     parsedData = NULL;
 237     dbMgr = NULL;
 238 }
 239
 240 CreateIdxStatement::~CreateIdxStatement()
 241 {
 242
 243 }
 244
 245 DbRetVal CreateIdxStatement::execute(int &rowsAffected)
 246 {
 247     DbRetVal rv = OK;
 248     if (parsedData->getFieldNameList().size() > 0)
 249     {
 250         HashIndexInitInfo *idxInfo = new HashIndexInitInfo();
 251         strcpy(idxInfo->tableName, parsedData->getTableName());
 252         ListIterator iter = parsedData->getFieldNameList().getIterator();
 253         FieldName *name = NULL;
 254         while (iter.hasElement())
 255         {
 256             name = (FieldName*)iter.nextElement();
 257             idxInfo->list.append(name->fldName);
 258         }
 259         idxInfo->indType = parsedData->getIndexType();
 260         idxInfo->isPrimary = parsedData->getPrimary();
 261         idxInfo->isUnique = parsedData->getUnique();
 262         int bucket = parsedData->getBucketSize();
 263         if(bucket!=0)
 264             idxInfo->bucketSize = bucket;
 265         rv = dbMgr->createIndex(parsedData->getIndexName(), idxInfo);
 266         delete idxInfo;
 267     }
 268     if (rv == OK) dbMgr->sendSignal(SIGCSQL1);
 269     return rv;
 270 }
 271
 272 // function for not to drop cached table
 273 DbRetVal isTableCached(char *tabName) // function added by :Jitendra
 274 {
 275
 276     DbRetVal rv =OK;
 277     FILE *fp;
 278     if (!Conf::config.useCache()) return OK;
 279     fp = fopen(Conf::config.getTableConfigFile(),"r");
 280     if(fp==NULL) return OK;
 281     char tablename[IDENTIFIER_LENGTH]; tablename[0] = '\0';
 282     char condition[IDENTIFIER_LENGTH]; condition[0]='\0';
 283     char fieldname[IDENTIFIER_LENGTH]; fieldname[0]='\0';
 284     char field[IDENTIFIER_LENGTH];  field[0]='\0';
 285     char dsnName[IDENTIFIER_LENGTH]; dsnName[0]='\0';
 286     int mode;
 287     while(!feof(fp))
 288     {
 289         fscanf(fp,"%d %s %s %s %s %s\n",&mode,tablename,fieldname,condition,field,dsnName);
 290         if(strcmp(tablename,tabName) ==0){
 291         fclose(fp);
 292         return ErrNoPrivilege;}
 293     }
 294     fclose(fp);
 295     return rv;
 296 }
 297
 298 DbRetVal DropTblStatement::execute(int &rowsAffected)
 299 {
 300     DbRetVal rv = OK; // newly added
 301     char *tab;
 302     tab = parsedData->getTableName();
 303
 304     DatabaseManagerImpl *dmgr = (DatabaseManagerImpl *)dbMgr;
 305     IsolationLevel iso = dmgr->txnMgr()->getIsoLevel();
 306     rv = dmgr->txnMgr()->rollback(dmgr->lockMgr());
 307     rv = dmgr->txnMgr()->startTransaction(dmgr->lockMgr(),iso);
 308 #ifndef MMDB
 309     int mode = TableConf::config.getTableMode(tab);
 310 //    rv = isTableCached(tab);
 311     if (mode != 0 && mode < 8) {
 312             printf("Cached table '%s' cannot be dropped.\n", tab);
 313         printf("uncache the table by 'cachetable -t %s -u' and drop.\n", tab);
 314             printError(ErrNoPrivilege, "Cached table '%s' cannot be dropped.", tab);
 315         return ErrNoPrivilege;
 316     }
 317     else if (mode == 8) {
 318         printf("Replicated table '%s' cannot be dropped.\n", tab);
 319         printf("Unreplicate the table by 'repltable -t %s -u' and drop.\n", tab);
 320         printError(ErrNoPrivilege, "Replicated table '%s' cannot be dropped.", tab);
 321         return ErrNoPrivilege;
 322     }
 323     else if (mode > 8) {
 324         printf("Table %s is cached and replicated. Cannot be dropped.\n", tab);
 325         printf("Uncache the table by 'cachetable -t %s -u'.\n", tab);
 326         printf("Unreplicated the table by 'repltable -t %s -u' and drop.\n", tab);
 327         printError(ErrNoPrivilege, "Table %s is cached and replicated. Cannot be dropped.", tab);
 328         return ErrNoPrivilege;
 329     }
 330 #endif
 331     rv = dbMgr->dropTable(parsedData->getTableName());
 332     if (rv == OK) dbMgr->sendSignal(SIGCSQL1);
 333     return rv;
 334 }
 335
 336 DbRetVal DropIdxStatement::execute(int &rowsAffected)
 337 {
 338     DbRetVal rv = OK;
 339     DatabaseManagerImpl *dmgr = (DatabaseManagerImpl *)dbMgr;
 340     IsolationLevel iso = dmgr->txnMgr()->getIsoLevel();
 341     rv = dmgr->txnMgr()->rollback(dmgr->lockMgr());
 342     rv = dmgr->txnMgr()->startTransaction(dmgr->lockMgr(),iso);
 343     rv = dmgr->dropIndex(parsedData->getIndexName());
 344     if (rv == OK) dbMgr->sendSignal(SIGCSQL1);
 345     return rv;
 346 }
 347
 348 //================== Truncate Table Statement ===============
 349
 350
 351 DbRetVal TruncateTblStatement::execute(int &rowsAffected)
 352 {
 353     DbRetVal rv = OK;
 354     table->setCondition(NULL);
 355     IsolationLevel level = ((DatabaseManagerImpl*)dbMgr)->txnMgr()->getIsoLevel();
 356     rv=((DatabaseManagerImpl*)dbMgr)->txnMgr()->commit(((DatabaseManagerImpl*)dbMgr)->lockMgr());
 357     if (rv != OK) return rv;
 358     rv=((DatabaseManagerImpl*)dbMgr)->txnMgr()->startTransaction(((DatabaseManagerImpl*)dbMgr)->lockMgr(),level);
 359     if (rv != OK) return rv;
 360
 361     rv = table->execute();
 362     if (rv != OK) return rv;
 363     rowsAffected = 0;
 364     table->setLoading(true);
 365     void *tuple;
 366     while(true)
 367     {
 368         tuple = (char*)table->fetchNoBind(rv);
 369         if (rv != OK) break;
 370         if (tuple == NULL) {break;}
 371         rv = table->deleteTuple();
 372         if (rv != OK) break;
 373         rowsAffected++;
 374     }
 375     table->closeScan();
 376     return rv;
 377 }
 378 DbRetVal TruncateTblStatement::resolve()
 379 {
 380    DbRetVal rv = OK;
 381    table = dbMgr->openTable(parsedData->getTableName());
 382     if (table == NULL)
 383     {
 384         printError(ErrNotExists, "Unable to open the table:Table not exists");
 385         return ErrNotExists;
 386     }
 387     return rv;
 388 }
 389
 390
 391
 392
 393
 394 //================== Compact Table Statement===================
 395 DbRetVal CompactTblStatement::resolve()
 396 {
 397     DbRetVal rv = OK;
 398     table = dbMgr->openTable(parsedData->getTableName());
 399     if (table == NULL)
 400     {
 401         printError(ErrNotExists, "Unable to open the table:Table not exists");
 402         return ErrNotExists;
 403     }
 404     return OK;
 405 }
 406 DbRetVal CompactTblStatement::execute(int &rowsAffected)
 407 {
 408     DbRetVal rv = OK;
 409     rv = table->compact();
 410     dbMgr->closeTable(table);
 411     return rv;
 412 }
 413 DbRetVal UserTblStatement::resolve()
 414 {
 415     uType = parsedData->getUserType();
 416     if( uType == CREATEUSER || uType == DROPUSER || (uType == ALTERUSER && strcmp(userName,parsedData->getUserName())!=0))
 417     {
 418        if(strcmp(userName,"root")!=0)
 419        {
 420            printError(ErrNoPrivilege,"Permission Denied. Login as root");
 421            return ErrNoPrivilege;
 422        }else if(uType == DROPUSER && strcmp(parsedData->getUserName(),"root")==0)
 423        {
 424             printError(ErrNoPrivilege,"Permission Denied. root user cannot be deleted");
 425             return ErrNoPrivilege;
 426        }
 427     }
 428     return OK;
 429 }
 430 DbRetVal UserTblStatement::execute(int &rowsAffected)
 431 {
 432     DbRetVal rv = OK;
 433     if( uType == CREATEUSER){
 434        rv =(DbRetVal) usrMgr->createUser(parsedData->getUserName(), parsedData->getPassWord());
 435     }else if(uType == DROPUSER){
 436        rv =(DbRetVal) usrMgr->deleteUser(parsedData->getUserName());
 437     }else{
 438        rv =(DbRetVal) usrMgr->changePassword(parsedData->getUserName(), parsedData->getPassWord());
 439     }
 440     return rv;
 441 }
 442