Return to legacy.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src

sqlite3

    1: /*
    2: ** 2001 September 15
    3: **
    4: ** The author disclaims copyright to this source code.  In place of
    5: ** a legal notice, here is a blessing:
    6: **
    7: **    May you do good and not evil.
    8: **    May you find forgiveness for yourself and forgive others.
    9: **    May you share freely, never taking more than you give.
   10: **
   11: *************************************************************************
   12: ** Main file for the SQLite library.  The routines in this file
   13: ** implement the programmer interface to the library.  Routines in
   14: ** other files are for internal use by SQLite and should not be
   15: ** accessed by users of the library.
   16: */
   17: 
   18: #include "sqliteInt.h"
   19: 
   20: /*
   21: ** Execute SQL code.  Return one of the SQLITE_ success/failure
   22: ** codes.  Also write an error message into memory obtained from
   23: ** malloc() and make *pzErrMsg point to that message.
   24: **
   25: ** If the SQL is a query, then for each row in the query result
   26: ** the xCallback() function is called.  pArg becomes the first
   27: ** argument to xCallback().  If xCallback=NULL then no callback
   28: ** is invoked, even for queries.
   29: */
   30: int sqlite3_exec(
   31:   sqlite3 *db,                /* The database on which the SQL executes */
   32:   const char *zSql,           /* The SQL to be executed */
   33:   sqlite3_callback xCallback, /* Invoke this callback routine */
   34:   void *pArg,                 /* First argument to xCallback() */
   35:   char **pzErrMsg             /* Write error messages here */
   36: ){
   37:   int rc = SQLITE_OK;         /* Return code */
   38:   const char *zLeftover;      /* Tail of unprocessed SQL */
   39:   sqlite3_stmt *pStmt = 0;    /* The current SQL statement */
   40:   char **azCols = 0;          /* Names of result columns */
   41:   int nRetry = 0;             /* Number of retry attempts */
   42:   int callbackIsInit;         /* True if callback data is initialized */
   43: 
   44:   if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
   45:   if( zSql==0 ) zSql = "";
   46: 
   47:   sqlite3_mutex_enter(db->mutex);
   48:   sqlite3Error(db, SQLITE_OK, 0);
   49:   while( (rc==SQLITE_OK || (rc==SQLITE_SCHEMA && (++nRetry)<2)) && zSql[0] ){
   50:     int nCol;
   51:     char **azVals = 0;
   52: 
   53:     pStmt = 0;
   54:     rc = sqlite3_prepare(db, zSql, -1, &pStmt, &zLeftover);
   55:     assert( rc==SQLITE_OK || pStmt==0 );
   56:     if( rc!=SQLITE_OK ){
   57:       continue;
   58:     }
   59:     if( !pStmt ){
   60:       /* this happens for a comment or white-space */
   61:       zSql = zLeftover;
   62:       continue;
   63:     }
   64: 
   65:     callbackIsInit = 0;
   66:     nCol = sqlite3_column_count(pStmt);
   67: 
   68:     while( 1 ){
   69:       int i;
   70:       rc = sqlite3_step(pStmt);
   71: 
   72:       /* Invoke the callback function if required */
   73:       if( xCallback && (SQLITE_ROW==rc || 
   74:           (SQLITE_DONE==rc && !callbackIsInit
   75:                            && db->flags&SQLITE_NullCallback)) ){
   76:         if( !callbackIsInit ){
   77:           azCols = sqlite3DbMallocZero(db, 2*nCol*sizeof(const char*) + 1);
   78:           if( azCols==0 ){
   79:             goto exec_out;
   80:           }
   81:           for(i=0; i<nCol; i++){
   82:             azCols[i] = (char *)sqlite3_column_name(pStmt, i);
   83:             /* sqlite3VdbeSetColName() installs column names as UTF8
   84:             ** strings so there is no way for sqlite3_column_name() to fail. */
   85:             assert( azCols[i]!=0 );
   86:           }
   87:           callbackIsInit = 1;
   88:         }
   89:         if( rc==SQLITE_ROW ){
   90:           azVals = &azCols[nCol];
   91:           for(i=0; i<nCol; i++){
   92:             azVals[i] = (char *)sqlite3_column_text(pStmt, i);
   93:             if( !azVals[i] && sqlite3_column_type(pStmt, i)!=SQLITE_NULL ){
   94:               db->mallocFailed = 1;
   95:               goto exec_out;
   96:             }
   97:           }
   98:         }
   99:         if( xCallback(pArg, nCol, azVals, azCols) ){
  100:           rc = SQLITE_ABORT;
  101:           sqlite3VdbeFinalize((Vdbe *)pStmt);
  102:           pStmt = 0;
  103:           sqlite3Error(db, SQLITE_ABORT, 0);
  104:           goto exec_out;
  105:         }
  106:       }
  107: 
  108:       if( rc!=SQLITE_ROW ){
  109:         rc = sqlite3VdbeFinalize((Vdbe *)pStmt);
  110:         pStmt = 0;
  111:         if( rc!=SQLITE_SCHEMA ){
  112:           nRetry = 0;
  113:           zSql = zLeftover;
  114:           while( sqlite3Isspace(zSql[0]) ) zSql++;
  115:         }
  116:         break;
  117:       }
  118:     }
  119: 
  120:     sqlite3DbFree(db, azCols);
  121:     azCols = 0;
  122:   }
  123: 
  124: exec_out:
  125:   if( pStmt ) sqlite3VdbeFinalize((Vdbe *)pStmt);
  126:   sqlite3DbFree(db, azCols);
  127: 
  128:   rc = sqlite3ApiExit(db, rc);
  129:   if( rc!=SQLITE_OK && ALWAYS(rc==sqlite3_errcode(db)) && pzErrMsg ){
  130:     int nErrMsg = 1 + sqlite3Strlen30(sqlite3_errmsg(db));
  131:     *pzErrMsg = sqlite3Malloc(nErrMsg);
  132:     if( *pzErrMsg ){
  133:       memcpy(*pzErrMsg, sqlite3_errmsg(db), nErrMsg);
  134:     }else{
  135:       rc = SQLITE_NOMEM;
  136:       sqlite3Error(db, SQLITE_NOMEM, 0);
  137:     }
  138:   }else if( pzErrMsg ){
  139:     *pzErrMsg = 0;
  140:   }
  141: 
  142:   assert( (rc&db->errMask)==rc );
  143:   sqlite3_mutex_leave(db->mutex);
  144:   return rc;
  145: }