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 = hashIndex;
  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
 153        //TODO : need a new addField function which can take FieldDef as parameter.
 154        if (!fDef->isDefault_ || fDef->isDefault_ && fDef->defaultValueBuf_[0] == '\0')  {
 155            i = tblDef.addField(fDef->fldName_, fDef->type_, fDef->length_,
 156                         NULL,fDef->isNull_,fDef->isAutoIncrement_);
 157        } else {
 158            i = tblDef.addField(fDef->fldName_, fDef->type_, fDef->length_,
 159                         fDef->defaultValueBuf_,fDef->isNull_,fDef->isAutoIncrement_);
 160        }
 161        if( 0 != i )
 162        {
 163           printError(ErrUnknown, "Error while adding field");
 164           rv = ErrUnknown;
 165           break;
 166        }
 167     }
 168     return rv;
 169 }
 170 /////////////////////////////////////
 171 DbRetVal CacheTblStatement::resolve()
 172 {
 173     DbRetVal rv = OK;
 174 #ifndef MMDB
 175     TableConf::config.init();
 176     cacheLoader.setConnParam(I_USER, I_PASS);
 177     cacheLoader.setTable(parsedData->getTableName());
 178     TableConf::config.setTable(parsedData->getTableName());
 179     if(parsedData->getHCondFld()){
 180         cacheLoader.setCondition(parsedData->getHCondition());// new one
 181         TableConf::config.setCondition(parsedData->getHCondition());
 182     }
 183     if(parsedData->getVCondFld()) {
 184         cacheLoader.setFieldListVal(parsedData->getVCondition());
 185         TableConf::config.setFieldListVal(parsedData->getVCondition());
 186     }
 187     if(parsedData->getPkFld()){
 188         cacheLoader.setFieldName(parsedData->getIndexName());
 189         TableConf::config.setFieldName(parsedData->getIndexName());
 190     }
 191     if(parsedData->getDSN()){
 192         cacheLoader.setDsnName(parsedData->getPKTableName());
 193         TableConf::config.setDsnName(parsedData->getPKTableName());
 194     }
 195     if( !(parsedData->getUnCache()))
 196     {
 197         rv = TableConf::config.isTableCached(parsedData->getTableName());
 198         if(rv == OK){
 199            printError(ErrAlready, "Table is already cached,unload table then try");
 200            return ErrAlready;
 201         }
 202     }
 203 #endif
 204     return OK;
 205 }
 206 DbRetVal CacheTblStatement::execute(int &rowsAffected)
 207 {
 208     DbRetVal rv = OK;
 209 #ifndef MMDB
 210     if( parsedData->getUnCache())
 211     {
 212         unsigned int mode =
 213                     TableConf::config.getTableMode(parsedData->getTableName());
 214         bool isCached = TableConf::config.isTableCached(mode);
 215         if (!isCached) {
 216             printError(ErrNotCached, "Table is not Cached");
 217             return ErrNotCached;
 218         }
 219         TableConf::config.removeFromCacheTableFile();
 220     } else {
 221         rv = cacheLoader.load(!(parsedData->getNoSchema()));
 222         if(rv == OK){
 223             TableConf::config.addToCacheTableFile(parsedData->getDirect());
 224         } else return rv;
 225     }
 226 #endif
 227     return OK;
 228 }
 229 ///////////////////////////////////////
 230 CreateIdxStatement::CreateIdxStatement()
 231 {
 232     parsedData = NULL;
 233     dbMgr = NULL;
 234 }
 235
 236 CreateIdxStatement::~CreateIdxStatement()
 237 {
 238
 239 }
 240
 241 DbRetVal CreateIdxStatement::execute(int &rowsAffected)
 242 {
 243     DbRetVal rv = OK;
 244     if (parsedData->getFieldNameList().size() > 0)
 245     {
 246         HashIndexInitInfo *idxInfo = new HashIndexInitInfo();
 247         strcpy(idxInfo->tableName, parsedData->getTableName());
 248         ListIterator iter = parsedData->getFieldNameList().getIterator();
 249         FieldName *name = NULL;
 250         while (iter.hasElement())
 251         {
 252             name = (FieldName*)iter.nextElement();
 253             idxInfo->list.append(name->fldName);
 254         }
 255         idxInfo->indType = parsedData->getIndexType();
 256         idxInfo->isPrimary = parsedData->getPrimary();
 257         idxInfo->isUnique = parsedData->getUnique();
 258         int bucket = parsedData->getBucketSize();
 259         if(bucket!=0)
 260             idxInfo->bucketSize = bucket;
 261         rv = dbMgr->createIndex(parsedData->getIndexName(), idxInfo);
 262         delete idxInfo;
 263     }
 264     if (rv == OK) dbMgr->sendSignal(SIGCSQL1);
 265     return rv;
 266 }
 267
 268 // function for not to drop cached table
 269 DbRetVal isTableCached(char *tabName) // function added by :Jitendra
 270 {
 271
 272     DbRetVal rv =OK;
 273     FILE *fp;
 274     if (!Conf::config.useCache()) return OK;
 275     fp = fopen(Conf::config.getTableConfigFile(),"r");
 276     if(fp==NULL) return OK;
 277     char tablename[IDENTIFIER_LENGTH]; tablename[0] = '\0';
 278     char condition[IDENTIFIER_LENGTH]; condition[0]='\0';
 279     char fieldname[IDENTIFIER_LENGTH]; fieldname[0]='\0';
 280     char field[IDENTIFIER_LENGTH];  field[0]='\0';
 281     char dsnName[IDENTIFIER_LENGTH]; dsnName[0]='\0';
 282     int mode;
 283     while(!feof(fp))
 284     {
 285         fscanf(fp,"%d %s %s %s %s %s\n",&mode,tablename,fieldname,condition,field,dsnName);
 286         if(strcmp(tablename,tabName) ==0){
 287         fclose(fp);
 288         return ErrNoPrivilege;}
 289     }
 290     fclose(fp);
 291     return rv;
 292 }
 293
 294 DbRetVal DropTblStatement::execute(int &rowsAffected)
 295 {
 296     DbRetVal rv = OK; // newly added
 297     char *tab;
 298     tab = parsedData->getTableName();
 299
 300     DatabaseManagerImpl *dmgr = (DatabaseManagerImpl *)dbMgr;
 301     IsolationLevel iso = dmgr->txnMgr()->getIsoLevel();
 302     rv = dmgr->txnMgr()->rollback(dmgr->lockMgr());
 303     rv = dmgr->txnMgr()->startTransaction(dmgr->lockMgr(),iso);
 304 #ifndef MMDB
 305     int mode = TableConf::config.getTableMode(tab);
 306 //    rv = isTableCached(tab);
 307     if (mode != 0 && mode < 8) {
 308             printf("Cached table '%s' cannot be dropped.\n", tab);
 309         printf("uncache the table by 'cachetable -t %s -u' and drop.\n", tab);
 310             printError(ErrNoPrivilege, "Cached table '%s' cannot be dropped.", tab);
 311         return ErrNoPrivilege;
 312     }
 313     else if (mode == 8) {
 314         printf("Replicated table '%s' cannot be dropped.\n", tab);
 315         printf("Unreplicate the table by 'repltable -t %s -u' and drop.\n", tab);
 316         printError(ErrNoPrivilege, "Replicated table '%s' cannot be dropped.", tab);
 317         return ErrNoPrivilege;
 318     }
 319     else if (mode > 8) {
 320         printf("Table %s is cached and replicated. Cannot be dropped.\n", tab);
 321         printf("Uncache the table by 'cachetable -t %s -u'.\n", tab);
 322         printf("Unreplicated the table by 'repltable -t %s -u' and drop.\n", tab);
 323         printError(ErrNoPrivilege, "Table %s is cached and replicated. Cannot be dropped.", tab);
 324         return ErrNoPrivilege;
 325     }
 326 #endif
 327     rv = dbMgr->dropTable(parsedData->getTableName());
 328     if (rv == OK) dbMgr->sendSignal(SIGCSQL1);
 329     return rv;
 330 }
 331
 332 DbRetVal DropIdxStatement::execute(int &rowsAffected)
 333 {
 334     DbRetVal rv = OK;
 335     rv = dbMgr->dropIndex(parsedData->getIndexName());
 336      if (rv == OK) dbMgr->sendSignal(SIGCSQL1);
 337     return rv;
 338 }
 339
 340 //================== Compact Table Statement===================
 341 DbRetVal CompactTblStatement::resolve()
 342 {
 343     DbRetVal rv = OK;
 344     table = dbMgr->openTable(parsedData->getTableName());
 345     if (table == NULL)
 346     {
 347         printError(ErrNotExists, "Unable to open the table:Table not exists");
 348         return ErrNotExists;
 349     }
 350     return OK;
 351 }
 352 DbRetVal CompactTblStatement::execute(int &rowsAffected)
 353 {
 354     DbRetVal rv = OK;
 355     rv = table->compact();
 356     dbMgr->closeTable(table);
 357     return rv;
 358 }
 359 DbRetVal UserTblStatement::resolve()
 360 {
 361     uType = parsedData->getUserType();
 362     if( uType == CREATEUSER || uType == DROPUSER || (uType == ALTERUSER && strcmp(userName,parsedData->getUserName())!=0))
 363     {
 364        if(strcmp(userName,"root")!=0)
 365        {
 366            printError(ErrNoPrivilege,"Permission Denied. Login as root");
 367            return ErrNoPrivilege;
 368        }else if(uType == DROPUSER && strcmp(parsedData->getUserName(),"root")==0)
 369        {
 370             printError(ErrNoPrivilege,"Permission Denied. root user cannot be deleted");
 371             return ErrNoPrivilege;
 372        }
 373     }
 374     return OK;
 375 }
 376 DbRetVal UserTblStatement::execute(int &rowsAffected)
 377 {
 378     DbRetVal rv = OK;
 379     if( uType == CREATEUSER){
 380        rv =(DbRetVal) usrMgr->createUser(parsedData->getUserName(), parsedData->getPassWord());
 381     }else if(uType == DROPUSER){
 382        rv =(DbRetVal) usrMgr->deleteUser(parsedData->getUserName());
 383     }else{
 384        rv =(DbRetVal) usrMgr->changePassword(parsedData->getUserName(), parsedData->getPassWord());
 385     }
 386     return rv;
 387 }
 388