Return to legacy.c CVS log

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

Annotation of embedaddon/sqlite3/src/legacy.c, revision 1.1

1.1     ! misho       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: }