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