src/gateway/SqlGwStatement.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  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20 #include <SqlGwConnection.h>
  21 #include <SqlOdbcStatement.h>
  22 #include <SqlGwStatement.h>
  23 #include <SqlLogStatement.h>
  24 #include <CacheTableLoader.h>
  25 #include <TableConfig.h>
  26
  27 DbRetVal SqlGwStatement::executeDirect(char *stmtstr)
  28 {
  29     DbRetVal rv = OK;
  30     int rows = 0;
  31     rv = prepare(stmtstr);
  32     if (rv != OK)  return rv;
  33     rv = execute(rows);
  34     if (rv != OK) return rv;
  35     return rv;
  36 }
  37
  38 DbRetVal SqlGwStatement::prepare(char *stmtstr)
  39 {
  40     char dsnname[IDENTIFIER_LENGTH];
  41     char *dsn = dsnname;
  42     char tab[IDENTIFIER_LENGTH];
  43
  44     bool connClose=false;
  45     bool SyntaxError=false;
  46     DbRetVal rv = OK,ret=OK;
  47     char *stmtTblName = NULL;
  48
  49     SqlGwConnection *conn = (SqlGwConnection*) con;
  50     if (!conn->isAdptConnected() && !conn->isCsqlConnected()) return ErrNoConnection;
  51     SqlOdbcStatement *ada=(SqlOdbcStatement*) adapter;
  52     struct MultiDSN *node = conn->multi_adapter_head; //
  53
  54     stmtHdlr = NoHandler;
  55     if (innerStmt) rv = innerStmt->prepare(stmtstr);
  56     if (rv == OK) isPrepared = true;
  57     if (rv == ErrNotOpen) connClose=true;//new line addded for MultiDsn
  58     if (rv == ErrSyntaxError) SyntaxError=true;//new line addded for MultiDsn
  59     stmtTblName = innerStmt->getTableName();
  60
  61     bool isAllcachedTableForJoin = true;
  62     int noOfTable = 0;
  63
  64     StatementType stype = innerStmt->getStmtType();
  65     printDebug(DM_Gateway,"Table Name %s\t Stmt Type %d\n",stmtTblName, stype);
  66     if (stype == CacheTableStatement || stype == CompactTableStatement)
  67     {
  68         stmtHdlr = CSqlHandler;
  69         return OK;
  70     }
  71
  72     ListIterator titer =innerStmt->getTableNameList().getIterator();
  73     while (titer.hasElement())
  74     {
  75         TableName *t  = (TableName*)titer.nextElement();
  76         ret = TableConf::config.isTableCached(t->tblName);
  77         if(ret!=OK) isAllcachedTableForJoin=false;
  78         noOfTable++;
  79     }
  80     if(noOfTable == 1) { isAllcachedTableForJoin = true; }
  81     mode = TableConf::config.getTableMode(stmtTblName);
  82     bool isCached = TableConf::config.isTableCached(mode);
  83     bool isSelStmt = innerStmt->isSelect();
  84     bool localTable = false;
  85     if (rv == OK && mode == 0) localTable = true;
  86     bool isDirect = mode & DIRECT_CACHE;
  87 /*    if((mode==2||mode==6) && !innerStmt->isSelect())
  88     {
  89        printError(ErrReadOnlyCache, "Partial Cache Condition Violation for Non select Dml statement\n");
  90        return ErrReadOnlyCache;
  91     } */
  92
  93     if ((rv == OK) && (!isDirect || isSelStmt) && isAllcachedTableForJoin)
  94     {
  95         stmtHdlr = CSqlHandler;
  96         if (localTable || isSelStmt || (( isCached) && Conf::config.getCacheMode()==ASYNC_MODE))
  97             return rv;
  98     }
  99     //TODO::add procedures also in the below checking
 100     if (!strncasecmp(stmtstr,"INSERT", 6) == 0 &&
 101         !strncasecmp(stmtstr, "UPDATE", 6) ==0 &&
 102         !strncasecmp(stmtstr, "SELECT", 6) ==0 &&
 103         !strncasecmp(stmtstr, "DELETE", 6) ==0 &&
 104         (NULL==strstr(stmtstr,"call ") && NULL == strstr(stmtstr,"CALL ")) )return rv;
 105
 106     printDebug(DM_Gateway, "Handled by csql %d\n", shouldCSqlHandle());
 107
 108     if (!shouldCSqlHandle()) stmtHdlr = AdapterHandler;
 109     if ( shouldCSqlHandle() && Conf::config.getCacheMode() == SYNC_MODE &&
 110          !isSelStmt && isCached) stmtHdlr = CSqlAndAdapterHandler;
 111
 112     printDebug(DM_Gateway, "Handled  %d\n", stmtHdlr);
 113     strcpy(tab, stmtTblName);
 114
 115     /*********The below code is for MultiDsn.***********/
 116
 117     //If Prepared by CSQL and if the table is cached.
 118     if(isPrepared && (ret = TableConf::config.getDsnForTable(tab,dsn)) == OK) {
 119         if (adapter && shouldAdapterHandle()) {
 120             adapter->setConnection(conn->getAdapterConnection(dsnname));
 121             rv = adapter->prepare(stmtstr);
 122             if (rv == OK) setToCommit(dsnname);
 123         }
 124     }
 125     //Default adapter should prepare when table name is not found by csql's prepare(),
 126     //This happens only when csql connection is down or there is a complex query.
 127      if((stmtHdlr == AdapterHandler && connClose) || SyntaxError){
 128        adapter->setConnection(conn->getAdapterConnection(Conf::config.getDSN()));
 129            if(adapter && shouldAdapterHandle()){
 130                rv = adapter->prepare(stmtstr);
 131                setToCommit(Conf::config.getDSN());
 132            }
 133     }
 134     //For non-cached TDB tables, where the table name is found in csql prepare.
 135     if(!isPrepared && !SyntaxError && !connClose) {
 136         if(conn->noOfCon == 1){
 137             adapter->setConnection(conn->getAdapterConnection(node->dsn));
 138             if(adapter && shouldAdapterHandle()) {
 139                 rv = adapter->prepare(stmtstr);
 140                 if(rv == OK) node->toCommit=true;
 141             }
 142          }else{
 143             while(node != NULL) {
 144                 if(adapter)
 145                 adapter->setConnection(conn->getAdapterConnection(node->dsn));
 146                 if(ada->isTableExists(tab)){
 147                     if(adapter && shouldAdapterHandle()){
 148                         rv = adapter->prepare(stmtstr);
 149                         if(rv == OK) node->toCommit=true;
 150                         break;
 151                     }
 152                 }
 153                 node=node->next;
 154             }//while Ends here....
 155         }
 156     }
 157     if(rv != OK) {
 158         printError(ErrBadCall, "Both adapter and csql could not prepare");
 159         isPrepared = false;
 160     }else isPrepared = true;
 161     return rv;
 162 }
 163
 164 bool SqlGwStatement::shouldAdapterHandle()
 165 {
 166     if (stmtHdlr == AdapterHandler  || (stmtHdlr == CSqlAndAdapterHandler)) return true;
 167     return false;
 168 }
 169 bool SqlGwStatement::shouldCSqlHandle()
 170 {
 171     SqlGwConnection *conn = (SqlGwConnection*) con;
 172     if (stmtHdlr == CSqlHandler ||
 173         stmtHdlr == CSqlAndAdapterHandler) return true;
 174     return false;
 175 }
 176 bool SqlGwStatement::isSelect()
 177 {
 178     bool retValue;
 179     if (adapter && shouldAdapterHandle()) retValue =  adapter->isSelect();
 180     if (innerStmt && shouldCSqlHandle()) retValue =  innerStmt->isSelect();
 181     return retValue;
 182 }
 183
 184 DbRetVal SqlGwStatement::execute(int &rowsAffected)
 185 {
 186     DbRetVal rv = OK;
 187     SqlGwConnection *conn = (SqlGwConnection*) con;
 188     if (!conn->isAdptConnected() && !conn->isCsqlConnected()) return ErrNoConnection;
 189     if (!isPrepared) { return ErrNotPrepared; }
 190     if (adapter && shouldAdapterHandle()) {
 191         rv = adapter->execute(rowsAffected);
 192     }
 193     if (rv != OK) return rv;
 194     if (shouldAdapterHandle())
 195     {
 196         GwHandler hdlr = conn->getTxnHandler();
 197         if (hdlr == NoHandler) conn->setTxnHandler(AdapterHandler);
 198         if (hdlr == CSqlHandler) conn->setTxnHandler(CSqlAndAdapterHandler);
 199     }
 200     if (innerStmt && shouldCSqlHandle()) rv = innerStmt->execute(rowsAffected);
 201     if (shouldCSqlHandle())
 202     {
 203         GwHandler hdlr = conn->getTxnHandler();
 204         if (hdlr == NoHandler) conn->setTxnHandler(CSqlHandler);
 205         if (hdlr == AdapterHandler) conn->setTxnHandler(CSqlAndAdapterHandler);
 206     }
 207     return rv;
 208 }
 209
 210 DbRetVal SqlGwStatement::bindParam(int pos, void* value)
 211 {
 212     DbRetVal rv = OK;
 213     printError(ErrWarning, "Deprecated and does not replicate or cache");
 214     return rv;
 215 }
 216
 217 DbRetVal SqlGwStatement::bindField(int pos, void* value)
 218 {
 219     DbRetVal rv = OK;
 220     //TODO::this will never be handled by both. check the flag for this
 221     if (adapter && shouldAdapterHandle()) rv = adapter->bindField(pos, value);
 222     if (rv != OK) return rv;
 223     if (innerStmt && shouldCSqlHandle()) rv = innerStmt->bindField(pos,value);
 224     return rv;
 225 }
 226
 227 void* SqlGwStatement::fetch()
 228 {
 229     //TODO::this will never be handled by both. check the flag for this
 230     if (adapter && shouldAdapterHandle()) return adapter->fetch();
 231     if (innerStmt && shouldCSqlHandle()) return innerStmt->fetch();
 232     return NULL;
 233 }
 234
 235 void* SqlGwStatement::fetch(DbRetVal &rv)
 236 {
 237     //TODO::this will never be handled by both. check the flag for this
 238     if (!isPrepared) { rv = ErrNotPrepared; return NULL; }
 239     if (adapter && shouldAdapterHandle()) return adapter->fetch(rv);
 240     if (innerStmt && shouldCSqlHandle()) return innerStmt->fetch(rv);
 241     return NULL;
 242 }
 243
 244 void* SqlGwStatement::fetchAndPrint(bool SQL)
 245 {
 246     //TODO::this will never be handled by both. check the flag for this
 247     if (adapter && shouldAdapterHandle()) return adapter->fetchAndPrint(SQL);
 248     if (innerStmt && shouldCSqlHandle()) return innerStmt->fetchAndPrint(SQL);
 249     return NULL;
 250 }
 251
 252 void* SqlGwStatement::next()
 253 {
 254     //TODO::this will never be handled by both. check the flag for this
 255     if (adapter && shouldAdapterHandle()) return adapter->next();
 256     if (innerStmt && shouldCSqlHandle()) return innerStmt->next();
 257     return NULL;
 258 }
 259
 260 DbRetVal SqlGwStatement::close()
 261 {
 262     //TODO::this will never be handled by both. check the flag for this
 263     if (adapter && shouldAdapterHandle()) return adapter->close();
 264     if (innerStmt && shouldCSqlHandle()) return innerStmt->close();
 265     return OK;
 266 }
 267
 268 void* SqlGwStatement::getFieldValuePtr( int pos )
 269 {
 270     //TODO::this will never be handled by both. check the flag for this
 271     if (adapter && shouldAdapterHandle()) return adapter->getFieldValuePtr(pos);
 272     if (innerStmt && shouldCSqlHandle()) return innerStmt->getFieldValuePtr(pos);
 273     return NULL;
 274 }
 275 void SqlGwStatement::getProjFieldType(int *data)
 276 {
 277    if (innerStmt && shouldCSqlHandle()) return innerStmt->getProjFieldType(data);
 278    if (adapter && shouldAdapterHandle()) return adapter->getProjFieldType(data);
 279 }
 280
 281 void* SqlGwStatement::getFieldValuePtr( char *name )
 282 {
 283    if (adapter && shouldAdapterHandle()) return adapter->getFieldValuePtr(name);
 284    if (innerStmt && shouldCSqlHandle()) return innerStmt->getFieldValuePtr(name);
 285    return NULL;
 286 }
 287 int SqlGwStatement::noOfProjFields()
 288 {
 289     //TODO::this will never be handled by both. check the flag for this
 290     if (innerStmt && shouldCSqlHandle()) return innerStmt->noOfProjFields();
 291     if (adapter && shouldAdapterHandle()) return adapter->noOfProjFields();
 292     return 0;
 293 }
 294
 295 int SqlGwStatement::noOfParamFields()
 296 {
 297     if (innerStmt && shouldCSqlHandle()) return innerStmt->noOfParamFields();
 298     if (adapter && shouldAdapterHandle()) return adapter->noOfParamFields();
 299     return 0;
 300 }
 301
 302 DbRetVal SqlGwStatement::getProjFldInfo (int projpos, FieldInfo *&fInfo)
 303 {
 304     if (innerStmt && shouldCSqlHandle()) return innerStmt->getProjFldInfo(projpos, fInfo);
 305     if (adapter && shouldAdapterHandle()) return adapter->getProjFldInfo(projpos, fInfo);
 306     return OK;
 307 }
 308
 309 DbRetVal SqlGwStatement::getParamFldInfo (int parampos, FieldInfo *&fInfo)
 310 {
 311     if (innerStmt && shouldCSqlHandle()) return innerStmt->getParamFldInfo(parampos, fInfo);
 312     if (adapter && shouldAdapterHandle()) return adapter->getParamFldInfo(parampos, fInfo);
 313     return OK;
 314 }
 315
 316 DbRetVal SqlGwStatement::free()
 317 {
 318     DbRetVal rv = OK;
 319     if (!isPrepared) return OK;
 320     if (adapter && shouldAdapterHandle()) rv = adapter->free();
 321     if (innerStmt && shouldCSqlHandle()) rv = innerStmt->free();
 322     stmtHdlr = NoHandler;
 323     isPrepared = false;
 324     return rv;
 325 }
 326 void SqlGwStatement::setShortParam(int paramPos, short value)
 327 {
 328     if (adapter && shouldAdapterHandle()) adapter->setShortParam(paramPos, value);
 329     if (innerStmt && shouldCSqlHandle()) innerStmt->setShortParam(paramPos,value);
 330     return;
 331 }
 332 void SqlGwStatement::setIntParam(int paramPos, int value)
 333 {
 334     if (adapter && shouldAdapterHandle()) adapter->setIntParam(paramPos, value);
 335     if (innerStmt && shouldCSqlHandle()) innerStmt->setIntParam(paramPos,value);
 336     return;
 337
 338 }
 339 void SqlGwStatement::setLongParam(int paramPos, long value)
 340 {
 341     if (adapter && shouldAdapterHandle()) adapter->setLongParam(paramPos, value);
 342     if (innerStmt && shouldCSqlHandle()) innerStmt->setLongParam(paramPos,value);
 343     return;
 344
 345 }
 346 void SqlGwStatement::setLongLongParam(int paramPos, long long value)
 347 {
 348     if (adapter && shouldAdapterHandle()) adapter->setLongLongParam(paramPos, value);
 349     if (innerStmt && shouldCSqlHandle()) innerStmt->setLongLongParam(paramPos,value);
 350     return;
 351 }
 352 void SqlGwStatement::setByteIntParam(int paramPos, ByteInt value)
 353 {
 354     if (adapter && shouldAdapterHandle()) adapter->setByteIntParam(paramPos, value);
 355     if (innerStmt && shouldCSqlHandle()) innerStmt->setByteIntParam(paramPos,value);
 356     return;
 357 }
 358 void SqlGwStatement::setFloatParam(int paramPos, float value)
 359 {
 360     if (adapter && shouldAdapterHandle()) adapter->setFloatParam(paramPos, value);
 361     if (innerStmt && shouldCSqlHandle()) innerStmt->setFloatParam(paramPos,value);
 362     return;
 363 }
 364 void SqlGwStatement::setDoubleParam(int paramPos, double value)
 365 {
 366     if (adapter && shouldAdapterHandle()) adapter->setDoubleParam(paramPos, value);
 367     if (innerStmt && shouldCSqlHandle()) innerStmt->setDoubleParam(paramPos,value);
 368     return;
 369
 370 }
 371 void SqlGwStatement::setStringParam(int paramPos, char *value)
 372 {
 373     if (adapter && shouldAdapterHandle()) adapter->setStringParam(paramPos, value);
 374     if (innerStmt && shouldCSqlHandle()) innerStmt->setStringParam(paramPos,value);
 375     return;
 376 }
 377 void SqlGwStatement::setDateParam(int paramPos, Date value)
 378 {
 379     if (adapter && shouldAdapterHandle()) adapter->setDateParam(paramPos, value);
 380     if (innerStmt && shouldCSqlHandle()) innerStmt->setDateParam(paramPos,value);
 381     return;
 382 }
 383 void SqlGwStatement::setTimeParam(int paramPos, Time value)
 384 {
 385     if (adapter && shouldAdapterHandle()) adapter->setTimeParam(paramPos, value);
 386     if (innerStmt && shouldCSqlHandle()) innerStmt->setTimeParam(paramPos,value);
 387     return;
 388 }
 389 void SqlGwStatement::setTimeStampParam(int paramPos, TimeStamp value)
 390 {
 391     if (adapter && shouldAdapterHandle()) adapter->setTimeStampParam(paramPos, value);
 392     if (innerStmt && shouldCSqlHandle()) innerStmt->setTimeStampParam(paramPos,value);
 393     return;
 394 }
 395 void SqlGwStatement::setBinaryParam(int paramPos, void *value, int length)
 396 {
 397     if (adapter && shouldAdapterHandle()) adapter->setBinaryParam(paramPos, value, length);
 398     if (innerStmt && shouldCSqlHandle()) innerStmt->setBinaryParam(paramPos,value, length);
 399 }
 400 bool SqlGwStatement::isFldNull(int pos)
 401 {
 402     if (adapter && shouldAdapterHandle()) return adapter->isFldNull(pos);
 403     if (innerStmt && shouldCSqlHandle()) return innerStmt->isFldNull(pos);
 404
 405 }
 406 bool SqlGwStatement::isFldNull(char *name)
 407 {
 408     if (adapter && shouldAdapterHandle()) return adapter->isFldNull(name);
 409     if (innerStmt && shouldCSqlHandle()) return innerStmt->isFldNull(name);
 410
 411 }
 412 void SqlGwStatement::setNull(int pos)
 413 {
 414     if (adapter && shouldAdapterHandle()) adapter->setNull(pos);
 415     if (innerStmt && shouldCSqlHandle()) innerStmt-> setNull(pos);
 416 }
 417 List SqlGwStatement::getAllTableNames(DbRetVal &ret)
 418 {
 419     printf("in csql\n"); if (innerStmt) return innerStmt->getAllTableNames(ret);
 420     printf("in Target Db\n"); if (adapter) adapter->getAllTableNames(ret);
 421 }
 422 List SqlGwStatement::getAllUserNames(DbRetVal &ret)
 423 {
 424     if (innerStmt) return innerStmt->getAllTableNames(ret);
 425     if (adapter) adapter->getAllTableNames(ret);
 426 }
 427
 428 ResultSetPlan SqlGwStatement::getResultSetPlan()
 429 {
 430    if (adapter && shouldAdapterHandle()) return adapter->getResultSetPlan();
 431    if (innerStmt && shouldCSqlHandle())  return innerStmt->getResultSetPlan();
 432    return Normal;
 433 }
 434 long long SqlGwStatement::getLastInsertedVal(DbRetVal &rv)
 435 {
 436     if (innerStmt) return innerStmt->getLastInsertedVal(rv);
 437     if (adapter) return adapter->getLastInsertedVal(rv);
 438 }
 439
 440 //Function for COMMIT according to its name DSN
 441 void SqlGwStatement::setToCommit(char *dsName)
 442 {
 443    SqlGwConnection *conn = (SqlGwConnection*) con;
 444    struct MultiDSN *node = conn->multi_adapter_head;
 445    while(node != NULL){
 446        if(strcmp(dsName,node->dsn)==0){
 447            node->toCommit=true;
 448            break;
 449        }
 450        node=node->next;
 451    }
 452 }
 453
 454
 455