src/sql/SqlStatement.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 "Statement.h"
  21 #include <SqlStatement.h>
  22 #include <dmllex.h>
  23
  24 char *lexInput;
  25 extern ParsedData *parsedData;
  26
  27 int yyparse ();
  28 List SqlStatement::getTableNameList()
  29 {
  30     return pData.getTableNameList();
  31 }
  32 SqlStatement::SqlStatement()
  33 {
  34     sqlCon = NULL;
  35     stmt = NULL;
  36     isPrepd = false;
  37 }
  38 void SqlStatement::setConnection(AbsSqlConnection *conn)
  39 {
  40     sqlCon = (SqlConnection*)conn;
  41     con = conn;
  42
  43 }
  44 void SqlStatement::setSqlConnection(SqlConnection *conn)
  45 {
  46     sqlCon = conn;
  47 }
  48
  49 DbRetVal SqlStatement::prepare(char *stmtstr)
  50 {
  51     DbRetVal rv = OK;
  52     if (! sqlCon->isConnectionOpen()) {
  53         printError(ErrNotOpen, "Connection not open");
  54         return ErrNotOpen;
  55     }
  56     if(isPrepared()) free();
  57     lexInput = stmtstr;
  58     parsedData = &pData;
  59     yy_scan_string( stmtstr );
  60     int rc = yyparse();
  61     if (rc != 0)
  62     {
  63         free();
  64         parsedData = NULL;
  65         yyrestart(yyin);
  66         return ErrSyntaxError;
  67     }
  68     stmt = StatementFactory::getStatement(parsedData);
  69     stmt->setDbMgr(sqlCon->getConnObject().getDatabaseManager());
  70     rv = stmt->resolve();
  71     if (rv != OK)
  72     {
  73         free();
  74         parsedData = NULL;
  75         yyrestart(yyin);
  76         return rv;
  77     }
  78     parsedData = NULL;
  79     yyrestart(yyin);
  80     isPrepd = true;
  81     return OK;
  82 }
  83
  84 char*  SqlStatement::getTableName()
  85 {
  86     return pData.getTableName();
  87 }
  88
  89 bool SqlStatement::isSelect()
  90 {
  91     if (pData.getStmtType() == SelectStatement) return true;
  92     return false;
  93 }
  94
  95 bool SqlStatement::isPrepared() { return isPrepd; }
  96
  97 DbRetVal SqlStatement::execute(int &rowsAffected)
  98 {
  99     DbRetVal rv = OK;
 100     if (! sqlCon->isConnectionOpen()) {
 101         printError(ErrNotOpen, "Connection not open");
 102         return ErrNotOpen;
 103     }
 104     if (! isPrepared()) {
 105         printError(ErrNotPrepared, "Statement Not Prepared");
 106         return ErrNotPrepared;
 107     }
 108     rv = stmt->execute(rowsAffected);
 109     return rv;
 110 }
 111
 112 void* SqlStatement::fetch()
 113 {
 114     if (! sqlCon->isConnectionOpen()) {
 115         printError(ErrNotOpen, "Connection not open");
 116         return NULL;
 117     }
 118     if (! isPrepared()) {
 119         printError(ErrNotPrepared, "Statement Not Prepared");
 120         return NULL;
 121     }
 122     if (pData.getStmtType() != SelectStatement) return NULL;
 123     SelStatement *selStmt = (SelStatement*) stmt;
 124     return selStmt->fetch();
 125 }
 126
 127 void* SqlStatement::fetch(DbRetVal &rv)
 128 {
 129     if (! sqlCon->isConnectionOpen()) {
 130         printError(ErrNotOpen, "Connection not open");
 131         return NULL;
 132     }
 133     if (! isPrepared()) {
 134         printError(ErrNotPrepared, "Statement Not Prepared");
 135         return NULL;
 136     }
 137     if (pData.getStmtType() != SelectStatement) return NULL;
 138     SelStatement *selStmt = (SelStatement*) stmt;
 139     return selStmt->fetch(rv);
 140 }
 141
 142 void* SqlStatement::fetchAndPrint(bool SQL)
 143 {
 144     if (! sqlCon->isConnectionOpen()) {
 145         printError(ErrNotOpen, "Connection not open");
 146         return NULL;
 147     }
 148     if (! isPrepared()) {
 149         printError(ErrNotPrepared, "Statement Not Prepared");
 150         return NULL;
 151     }
 152     if (pData.getStmtType() != SelectStatement) return NULL;
 153     SelStatement *selStmt = (SelStatement*) stmt;
 154     return selStmt->fetchAndPrint(SQL);
 155 }
 156
 157 DbRetVal SqlStatement::bindParam(int pos, void* value)
 158 {
 159     DbRetVal rv = OK;
 160     rv = stmt->setParam(pos, value);
 161     return rv;
 162 }
 163
 164 DbRetVal SqlStatement::bindField(int pos, void* value)
 165 {
 166     DbRetVal rv = OK;
 167     if (pData.getStmtType() != SelectStatement) return ErrBadCall;
 168     SelStatement *selStmt = (SelStatement*) stmt;
 169     rv = selStmt->setBindField(pos, value);
 170     return rv;
 171 }
 172 void* SqlStatement::next()
 173 {
 174     if (pData.getStmtType() != SelectStatement) return 0;
 175     SelStatement *selStmt = (SelStatement*) stmt;
 176     return( (void*) selStmt->next() );
 177 }
 178
 179 bool SqlStatement::isFldNull(int pos)
 180 {
 181     if (pData.getStmtType() != SelectStatement) return 0;
 182     SelStatement *selStmt = (SelStatement*) stmt;
 183     return (selStmt->isFldNull(pos));
 184 }
 185
 186 bool SqlStatement::isFldNull(char *name)
 187 {
 188     if (pData.getStmtType() != SelectStatement) return 0;
 189     SelStatement *selStmt = (SelStatement*) stmt;
 190     return (selStmt->isFldNull(name));
 191 }
 192
 193 DbRetVal SqlStatement::close()
 194 {
 195     if (pData.getStmtType() != SelectStatement) return OK;
 196     SelStatement *selStmt = (SelStatement*) stmt;
 197     return selStmt->close();
 198 }
 199
 200 void* SqlStatement::getParamValuePtr( int pos )
 201 {
 202     //if (pData.getStmtType() != SelectStatement) return 0;
 203     DmlStatement *dmlStmt = (DmlStatement*) stmt;
 204     return( (void*) dmlStmt->getParamValuePtr( pos ) );
 205 }
 206
 207 char* SqlStatement::getFieldName( int pos )
 208 {
 209     if (pData.getStmtType() != SelectStatement) return 0;
 210     SelStatement *selStmt = (SelStatement*) stmt;
 211     return( (char*) selStmt->getFieldName( pos ) );
 212 }
 213
 214 DataType SqlStatement::getFieldType( int pos )
 215 {
 216     if (pData.getStmtType() != SelectStatement) return typeUnknown;
 217     SelStatement *selStmt = (SelStatement*) stmt;
 218     return( (DataType) selStmt->getFieldType( pos ) );
 219 }
 220 int SqlStatement::getFieldLength( int pos )
 221 {
 222     if (pData.getStmtType() != SelectStatement) return 0;
 223     SelStatement *selStmt = (SelStatement*) stmt;
 224     return( (int) selStmt->getFieldLength( pos ) );
 225 }
 226
 227 void* SqlStatement::getFieldValuePtr( int pos )
 228 {
 229     if (pData.getStmtType() != SelectStatement) return 0;
 230     SelStatement *selStmt = (SelStatement*) stmt;
 231     return( (void*) selStmt->getFieldValuePtr( pos ) );
 232 }
 233
 234 int SqlStatement::noOfProjFields()
 235 {
 236     if (pData.getStmtType() != SelectStatement) return 0;
 237     SelStatement *selStmt = (SelStatement*) stmt;
 238     return selStmt->noOfProjFields();
 239 }
 240
 241 int SqlStatement::noOfParamFields()
 242 {
 243     return stmt->noOfParamFields();
 244 }
 245
 246 DbRetVal SqlStatement::getProjFldInfo (int projpos, FieldInfo *&fInfo)
 247 {
 248     DbRetVal rv = OK;
 249     if (pData.getStmtType() != SelectStatement) return ErrBadCall;
 250     SelStatement *selStmt = (SelStatement*) stmt;
 251     rv = selStmt->getProjFldInfo(projpos, fInfo);
 252     return rv;
 253 }
 254
 255 DbRetVal SqlStatement::getParamFldInfo (int parampos, FieldInfo *&fInfo)
 256 {
 257     DbRetVal rv = OK;
 258     if (pData.getStmtType() ==SelectStatement ||
 259         pData.getStmtType() ==InsertStatement ||
 260         pData.getStmtType() ==UpdateStatement ||
 261         pData.getStmtType() ==DeleteStatement)
 262     {
 263
 264         DmlStatement *dmlStmt = (DmlStatement*) stmt;
 265         rv = dmlStmt->getParamFldInfo(parampos, fInfo);
 266     }
 267     return rv;
 268 }
 269
 270 DbRetVal SqlStatement::free()
 271 {
 272     delete stmt;
 273     stmt = NULL;
 274     pData.reset();
 275     isPrepd = false;
 276     return OK;
 277 }
 278
 279 void SqlStatement::setNull(int pos)
 280 {
 281     stmt->setNull(pos);
 282 }
 283 void SqlStatement::setShortParam(int paramPos, short value)
 284 {
 285     stmt->setShortParam(paramPos, value);
 286 }
 287 void SqlStatement::setIntParam(int paramPos, int value)
 288 {
 289     stmt->setIntParam(paramPos, value);
 290 }
 291 void SqlStatement::setLongParam(int paramPos, long value)
 292 {
 293     stmt->setLongParam(paramPos, value);
 294 }
 295 void SqlStatement::setLongLongParam(int paramPos, long long value)
 296 {
 297     stmt->setLongLongParam(paramPos, value);
 298 }
 299 void SqlStatement::setByteIntParam(int paramPos, ByteInt value)
 300 {
 301     stmt->setByteIntParam(paramPos, value);
 302 }
 303 void SqlStatement::setFloatParam(int paramPos, float value)
 304 {
 305     stmt->setFloatParam(paramPos, value);
 306 }
 307 void SqlStatement::setDoubleParam(int paramPos, double value)
 308 {
 309     stmt->setDoubleParam(paramPos, value);
 310 }
 311 void SqlStatement::setStringParam(int paramPos, char *value)
 312 {
 313     stmt->setStringParam(paramPos, value);
 314 }
 315 void SqlStatement::setDateParam(int paramPos, Date value)
 316 {
 317     stmt->setDateParam(paramPos, value);
 318 }
 319 void SqlStatement::setTimeParam(int paramPos, Time value)
 320 {
 321     stmt->setTimeParam(paramPos, value);
 322 }
 323 void SqlStatement::setTimeStampParam(int paramPos, TimeStamp value)
 324 {
 325     stmt->setTimeStampParam(paramPos, value);
 326 }
 327 void SqlStatement::setBinaryParam(int paramPos, void *value, int length)
 328 {
 329     stmt->setBinaryParam(paramPos, value, length);
 330 }
 331 int SqlStatement::getFldPos(char *name)
 332 {
 333     return stmt->getFldPos(name);
 334 }
 335 List SqlStatement::getAllTableNames(DbRetVal &ret)
 336 {
 337     DatabaseManager *dbMgr = sqlCon->getConnObject().getDatabaseManager();
 338     return dbMgr->getAllTableNames();
 339 }
 340
 341 void SqlStatement::setLoading(bool flag)
 342 {
 343     if (pData.getStmtType() == InsertStatement||
 344         pData.getStmtType() == UpdateStatement||
 345         pData.getStmtType() == DeleteStatement)
 346     {
 347         DmlStatement *dmlStmt = (DmlStatement*) stmt;
 348         dmlStmt->setLoading(flag);
 349     }
 350     return;
 351 }