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 <SqlGwStatement.h>
  21 #include <SqlLogStatement.h>
  22
  23 DbRetVal SqlGwStatement::prepare(char *stmtstr)
  24 {
  25     DbRetVal rv = OK;
  26     SqlGwConnection *conn = (SqlGwConnection*) con;
  27     //conn->connectCSqlIfNotConnected();
  28     //conn->connectAdapterIfNotConnected();
  29     stmtHdlr = NoHandler;
  30     if (innerStmt) rv = innerStmt->prepare(stmtstr);
  31     SqlLogStatement *stmt = (SqlLogStatement*) innerStmt;
  32     if (rv == OK) {
  33         if (!stmt->isCached) {
  34             stmtHdlr = CSqlHandler;
  35             return rv;
  36         }else {
  37             if (stmt->mode != TABLE_OSYNC) {
  38                 stmtHdlr = CSqlHandler;
  39                 return rv;
  40             }else {
  41                 stmtHdlr = CSqlAndAdapterHandler;
  42             }
  43         }
  44     }
  45
  46     //TODO::add procedures also in the below checking
  47     if (!strncasecmp(stmtstr,"INSERT", 6) == 0 &&
  48         !strncasecmp(stmtstr, "UPDATE", 6) ==0 &&
  49         !strncasecmp(stmtstr, "SELECT", 6) ==0 &&
  50         !strncasecmp(stmtstr, "DELETE", 6) ==0) return rv;
  51
  52     //prepare failed. means table not there in csql->uncached table
  53     //or sql statement is complex and csql parser failed
  54     if (adapter) rv = adapter->prepare(stmtstr);
  55     if (rv == OK) {
  56         printDebug(DM_Gateway, "Handled by csql %d\n", shouldCSqlHandle());
  57         if (!shouldCSqlHandle()) stmtHdlr = AdapterHandler;
  58         else stmtHdlr = CSqlAndAdapterHandler;
  59         printDebug(DM_Gateway, "Handled  %d\n", stmtHdlr);
  60     }
  61     else
  62         printError(ErrSysInit, "Both csql and adapter could not prepare\n");
  63     return rv;
  64 }
  65 bool SqlGwStatement::shouldAdapterHandle()
  66 {
  67     if (stmtHdlr == AdapterHandler ||
  68         stmtHdlr == CSqlAndAdapterHandler) return true;
  69     return false;
  70 }
  71 bool SqlGwStatement::shouldCSqlHandle()
  72 {
  73     SqlGwConnection *conn = (SqlGwConnection*) con;
  74     if (stmtHdlr == CSqlHandler ||
  75         stmtHdlr == CSqlAndAdapterHandler) return true;
  76     return false;
  77 }
  78 bool SqlGwStatement::isSelect()
  79 {
  80     bool retValue;
  81     if (adapter && shouldAdapterHandle()) retValue =  adapter->isSelect();
  82     if (innerStmt && shouldCSqlHandle()) retValue =  innerStmt->isSelect();
  83     return retValue;
  84 }
  85
  86 DbRetVal SqlGwStatement::execute(int &rowsAffected)
  87 {
  88     DbRetVal rv = OK;
  89     SqlGwConnection *conn = (SqlGwConnection*) con;
  90     if (adapter && shouldAdapterHandle()) rv = adapter->execute(rowsAffected);
  91     if (rv != OK) return rv;
  92     if (shouldAdapterHandle())
  93     {
  94         GwHandler hdlr = conn->getTxnHandler();
  95         if (hdlr == NoHandler) conn->setTxnHandler(AdapterHandler);
  96         if (hdlr == CSqlHandler) conn->setTxnHandler(CSqlAndAdapterHandler);
  97     }
  98     if (innerStmt && shouldCSqlHandle()) rv = innerStmt->execute(rowsAffected);
  99     if (shouldCSqlHandle())
 100     {
 101         GwHandler hdlr = conn->getTxnHandler();
 102         if (hdlr == NoHandler) conn->setTxnHandler(CSqlHandler);
 103         if (hdlr == AdapterHandler) conn->setTxnHandler(CSqlAndAdapterHandler);
 104     }
 105     return rv;
 106 }
 107
 108 DbRetVal SqlGwStatement::bindParam(int pos, void* value)
 109 {
 110     DbRetVal rv = OK;
 111     printError(ErrWarning, "Deprecated and does not replicate or cache");
 112     return rv;
 113 }
 114
 115 DbRetVal SqlGwStatement::bindField(int pos, void* value)
 116 {
 117     DbRetVal rv = OK;
 118     //TODO::this will never be handled by both. check the flag for this
 119     if (adapter && shouldAdapterHandle()) rv = adapter->bindField(pos, value);
 120     if (rv != OK) return rv;
 121     if (innerStmt && shouldCSqlHandle()) rv = innerStmt->bindField(pos,value);
 122     return rv;
 123 }
 124 void* SqlGwStatement::fetch()
 125 {
 126     //TODO::this will never be handled by both. check the flag for this
 127     if (adapter && shouldAdapterHandle()) return adapter->fetch();
 128     if (innerStmt && shouldCSqlHandle()) return innerStmt->fetch();
 129     return NULL;
 130 }
 131
 132 void* SqlGwStatement::fetchAndPrint(bool SQL)
 133 {
 134     //TODO::this will never be handled by both. check the flag for this
 135     if (adapter && shouldAdapterHandle()) return adapter->fetchAndPrint(SQL);
 136     if (innerStmt && shouldCSqlHandle()) return innerStmt->fetchAndPrint(SQL);
 137     return NULL;
 138 }
 139
 140 void* SqlGwStatement::next()
 141 {
 142     //TODO::this will never be handled by both. check the flag for this
 143     if (adapter && shouldAdapterHandle()) return adapter->next();
 144     if (innerStmt && shouldCSqlHandle()) return innerStmt->next();
 145     return NULL;
 146 }
 147
 148 DbRetVal SqlGwStatement::close()
 149 {
 150     //TODO::this will never be handled by both. check the flag for this
 151     if (adapter && shouldAdapterHandle()) return adapter->close();
 152     if (innerStmt && shouldCSqlHandle()) return innerStmt->close();
 153     return OK;
 154 }
 155
 156 void* SqlGwStatement::getFieldValuePtr( int pos )
 157 {
 158     //TODO::this will never be handled by both. check the flag for this
 159     if (adapter && shouldAdapterHandle()) return adapter->getFieldValuePtr(pos);
 160     if (innerStmt && shouldCSqlHandle()) return innerStmt->getFieldValuePtr(pos);
 161     return NULL;
 162 }
 163
 164 int SqlGwStatement::noOfProjFields()
 165 {
 166     //TODO::this will never be handled by both. check the flag for this
 167     if (innerStmt && shouldCSqlHandle()) return innerStmt->noOfProjFields();
 168     if (adapter && shouldAdapterHandle()) return adapter->noOfProjFields();
 169     return 0;
 170 }
 171
 172 int SqlGwStatement::noOfParamFields()
 173 {
 174     if (innerStmt && shouldCSqlHandle()) return innerStmt->noOfParamFields();
 175     if (adapter && shouldAdapterHandle()) return adapter->noOfParamFields();
 176     return 0;
 177 }
 178
 179 DbRetVal SqlGwStatement::getProjFldInfo (int projpos, FieldInfo *&fInfo)
 180 {
 181     if (innerStmt && shouldCSqlHandle()) return innerStmt->getProjFldInfo(projpos, fInfo);
 182     if (adapter && shouldAdapterHandle()) return adapter->getProjFldInfo(projpos, fInfo);
 183     return OK;
 184 }
 185
 186 DbRetVal SqlGwStatement::getParamFldInfo (int parampos, FieldInfo *&fInfo)
 187 {
 188     if (innerStmt && shouldCSqlHandle()) return innerStmt->getParamFldInfo(parampos, fInfo);
 189     if (adapter && shouldAdapterHandle()) return adapter->getParamFldInfo(parampos, fInfo);
 190     return OK;
 191 }
 192
 193 DbRetVal SqlGwStatement::free()
 194 {
 195     DbRetVal rv = OK;
 196     if (adapter && shouldAdapterHandle()) rv = adapter->free();
 197     if (innerStmt && shouldCSqlHandle()) rv = innerStmt->free();
 198     return rv;
 199 }
 200 void SqlGwStatement::setShortParam(int paramPos, short value)
 201 {
 202     if (adapter && shouldAdapterHandle()) adapter->setShortParam(paramPos, value);
 203     if (innerStmt && shouldCSqlHandle()) innerStmt->setShortParam(paramPos,value);
 204     return;
 205 }
 206 void SqlGwStatement::setIntParam(int paramPos, int value)
 207 {
 208     if (adapter && shouldAdapterHandle()) adapter->setIntParam(paramPos, value);
 209     if (innerStmt && shouldCSqlHandle()) innerStmt->setIntParam(paramPos,value);
 210     return;
 211
 212 }
 213 void SqlGwStatement::setLongParam(int paramPos, long value)
 214 {
 215     if (adapter && shouldAdapterHandle()) adapter->setLongParam(paramPos, value);
 216     if (innerStmt && shouldCSqlHandle()) innerStmt->setLongParam(paramPos,value);
 217     return;
 218
 219 }
 220 void SqlGwStatement::setLongLongParam(int paramPos, long long value)
 221 {
 222     if (adapter && shouldAdapterHandle()) adapter->setLongLongParam(paramPos, value);
 223     if (innerStmt && shouldCSqlHandle()) innerStmt->setLongLongParam(paramPos,value);
 224     return;
 225 }
 226 void SqlGwStatement::setByteIntParam(int paramPos, ByteInt value)
 227 {
 228     if (adapter && shouldAdapterHandle()) adapter->setByteIntParam(paramPos, value);
 229     if (innerStmt && shouldCSqlHandle()) innerStmt->setByteIntParam(paramPos,value);
 230     return;
 231 }
 232 void SqlGwStatement::setFloatParam(int paramPos, float value)
 233 {
 234     if (adapter && shouldAdapterHandle()) adapter->setFloatParam(paramPos, value);
 235     if (innerStmt && shouldCSqlHandle()) innerStmt->setFloatParam(paramPos,value);
 236     return;
 237 }
 238 void SqlGwStatement::setDoubleParam(int paramPos, double value)
 239 {
 240     if (adapter && shouldAdapterHandle()) adapter->setDoubleParam(paramPos, value);
 241     if (innerStmt && shouldCSqlHandle()) innerStmt->setDoubleParam(paramPos,value);
 242     return;
 243
 244 }
 245 void SqlGwStatement::setStringParam(int paramPos, char *value)
 246 {
 247     if (adapter && shouldAdapterHandle()) adapter->setStringParam(paramPos, value);
 248     if (innerStmt && shouldCSqlHandle()) innerStmt->setStringParam(paramPos,value);
 249     return;
 250 }
 251 void SqlGwStatement::setDateParam(int paramPos, Date value)
 252 {
 253     if (adapter && shouldAdapterHandle()) adapter->setDateParam(paramPos, value);
 254     if (innerStmt && shouldCSqlHandle()) innerStmt->setDateParam(paramPos,value);
 255     return;
 256 }
 257 void SqlGwStatement::setTimeParam(int paramPos, Time value)
 258 {
 259     if (adapter && shouldAdapterHandle()) adapter->setTimeParam(paramPos, value);
 260     if (innerStmt && shouldCSqlHandle()) innerStmt->setTimeParam(paramPos,value);
 261     return;
 262 }
 263 void SqlGwStatement::setTimeStampParam(int paramPos, TimeStamp value)
 264 {
 265     if (adapter && shouldAdapterHandle()) adapter->setTimeStampParam(paramPos, value);
 266     if (innerStmt && shouldCSqlHandle()) innerStmt->setTimeStampParam(paramPos,value);
 267     return;
 268 }