Annotation of embedaddon/php/ext/sqlite/libsqlite/src/table.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: ** This file contains the sqlite_get_table() and sqlite_free_table()
        !            13: ** interface routines.  These are just wrappers around the main
        !            14: ** interface routine of sqlite_exec().
        !            15: **
        !            16: ** These routines are in a separate files so that they will not be linked
        !            17: ** if they are not used.
        !            18: */
        !            19: #include <stdlib.h>
        !            20: #include <string.h>
        !            21: #include "sqliteInt.h"
        !            22: 
        !            23: /*
        !            24: ** This structure is used to pass data from sqlite_get_table() through
        !            25: ** to the callback function is uses to build the result.
        !            26: */
        !            27: typedef struct TabResult {
        !            28:   char **azResult;
        !            29:   char *zErrMsg;
        !            30:   int nResult;
        !            31:   int nAlloc;
        !            32:   int nRow;
        !            33:   int nColumn;
        !            34:   long nData;
        !            35:   int rc;
        !            36: } TabResult;
        !            37: 
        !            38: /*
        !            39: ** This routine is called once for each row in the result table.  Its job
        !            40: ** is to fill in the TabResult structure appropriately, allocating new
        !            41: ** memory as necessary.
        !            42: */
        !            43: static int sqlite_get_table_cb(void *pArg, int nCol, char **argv, char **colv){
        !            44:   TabResult *p = (TabResult*)pArg;
        !            45:   int need;
        !            46:   int i;
        !            47:   char *z;
        !            48: 
        !            49:   /* Make sure there is enough space in p->azResult to hold everything
        !            50:   ** we need to remember from this invocation of the callback.
        !            51:   */
        !            52:   if( p->nRow==0 && argv!=0 ){
        !            53:     need = nCol*2;
        !            54:   }else{
        !            55:     need = nCol;
        !            56:   }
        !            57:   if( p->nData + need >= p->nAlloc ){
        !            58:     char **azNew;
        !            59:     p->nAlloc = p->nAlloc*2 + need + 1;
        !            60:     azNew = realloc( p->azResult, sizeof(char*)*p->nAlloc );
        !            61:     if( azNew==0 ){
        !            62:       p->rc = SQLITE_NOMEM;
        !            63:       return 1;
        !            64:     }
        !            65:     p->azResult = azNew;
        !            66:   }
        !            67: 
        !            68:   /* If this is the first row, then generate an extra row containing
        !            69:   ** the names of all columns.
        !            70:   */
        !            71:   if( p->nRow==0 ){
        !            72:     p->nColumn = nCol;
        !            73:     for(i=0; i<nCol; i++){
        !            74:       if( colv[i]==0 ){
        !            75:         z = 0;
        !            76:       }else{
        !            77:         z = malloc( strlen(colv[i])+1 );
        !            78:         if( z==0 ){
        !            79:           p->rc = SQLITE_NOMEM;
        !            80:           return 1;
        !            81:         }
        !            82:         strcpy(z, colv[i]);
        !            83:       }
        !            84:       p->azResult[p->nData++] = z;
        !            85:     }
        !            86:   }else if( p->nColumn!=nCol ){
        !            87:     sqliteSetString(&p->zErrMsg,
        !            88:        "sqlite_get_table() called with two or more incompatible queries",
        !            89:        (char*)0);
        !            90:     p->rc = SQLITE_ERROR;
        !            91:     return 1;
        !            92:   }
        !            93: 
        !            94:   /* Copy over the row data
        !            95:   */
        !            96:   if( argv!=0 ){
        !            97:     for(i=0; i<nCol; i++){
        !            98:       if( argv[i]==0 ){
        !            99:         z = 0;
        !           100:       }else{
        !           101:         z = malloc( strlen(argv[i])+1 );
        !           102:         if( z==0 ){
        !           103:           p->rc = SQLITE_NOMEM;
        !           104:           return 1;
        !           105:         }
        !           106:         strcpy(z, argv[i]);
        !           107:       }
        !           108:       p->azResult[p->nData++] = z;
        !           109:     }
        !           110:     p->nRow++;
        !           111:   }
        !           112:   return 0;
        !           113: }
        !           114: 
        !           115: /*
        !           116: ** Query the database.  But instead of invoking a callback for each row,
        !           117: ** malloc() for space to hold the result and return the entire results
        !           118: ** at the conclusion of the call.
        !           119: **
        !           120: ** The result that is written to ***pazResult is held in memory obtained
        !           121: ** from malloc().  But the caller cannot free this memory directly.  
        !           122: ** Instead, the entire table should be passed to sqlite_free_table() when
        !           123: ** the calling procedure is finished using it.
        !           124: */
        !           125: int sqlite_get_table(
        !           126:   sqlite *db,                 /* The database on which the SQL executes */
        !           127:   const char *zSql,           /* The SQL to be executed */
        !           128:   char ***pazResult,          /* Write the result table here */
        !           129:   int *pnRow,                 /* Write the number of rows in the result here */
        !           130:   int *pnColumn,              /* Write the number of columns of result here */
        !           131:   char **pzErrMsg             /* Write error messages here */
        !           132: ){
        !           133:   int rc;
        !           134:   TabResult res;
        !           135:   if( pazResult==0 ){ return SQLITE_ERROR; }
        !           136:   *pazResult = 0;
        !           137:   if( pnColumn ) *pnColumn = 0;
        !           138:   if( pnRow ) *pnRow = 0;
        !           139:   res.zErrMsg = 0;
        !           140:   res.nResult = 0;
        !           141:   res.nRow = 0;
        !           142:   res.nColumn = 0;
        !           143:   res.nData = 1;
        !           144:   res.nAlloc = 20;
        !           145:   res.rc = SQLITE_OK;
        !           146:   res.azResult = malloc( sizeof(char*)*res.nAlloc );
        !           147:   if( res.azResult==0 ){
        !           148:     return SQLITE_NOMEM;
        !           149:   }
        !           150:   res.azResult[0] = 0;
        !           151:   rc = sqlite_exec(db, zSql, sqlite_get_table_cb, &res, pzErrMsg);
        !           152:   if( res.azResult ){
        !           153:     res.azResult[0] = (char*)res.nData;
        !           154:   }
        !           155:   if( rc==SQLITE_ABORT ){
        !           156:     sqlite_free_table(&res.azResult[1]);
        !           157:     if( res.zErrMsg ){
        !           158:       if( pzErrMsg ){
        !           159:         free(*pzErrMsg);
        !           160:         *pzErrMsg = res.zErrMsg;
        !           161:         sqliteStrRealloc(pzErrMsg);
        !           162:       }else{
        !           163:         sqliteFree(res.zErrMsg);
        !           164:       }
        !           165:     }
        !           166:     return res.rc;
        !           167:   }
        !           168:   sqliteFree(res.zErrMsg);
        !           169:   if( rc!=SQLITE_OK ){
        !           170:     sqlite_free_table(&res.azResult[1]);
        !           171:     return rc;
        !           172:   }
        !           173:   if( res.nAlloc>res.nData ){
        !           174:     char **azNew;
        !           175:     azNew = realloc( res.azResult, sizeof(char*)*(res.nData+1) );
        !           176:     if( azNew==0 ){
        !           177:       sqlite_free_table(&res.azResult[1]);
        !           178:       return SQLITE_NOMEM;
        !           179:     }
        !           180:     res.nAlloc = res.nData+1;
        !           181:     res.azResult = azNew;
        !           182:   }
        !           183:   *pazResult = &res.azResult[1];
        !           184:   if( pnColumn ) *pnColumn = res.nColumn;
        !           185:   if( pnRow ) *pnRow = res.nRow;
        !           186:   return rc;
        !           187: }
        !           188: 
        !           189: /*
        !           190: ** This routine frees the space the sqlite_get_table() malloced.
        !           191: */
        !           192: void sqlite_free_table(
        !           193:   char **azResult             /* Result returned from from sqlite_get_table() */
        !           194: ){
        !           195:   if( azResult ){
        !           196:     int i, n;
        !           197:     azResult--;
        !           198:     if( azResult==0 ) return;
        !           199:     n = (int)(long)azResult[0];
        !           200:     for(i=1; i<n; i++){ if( azResult[i] ) free(azResult[i]); }
        !           201:     free(azResult);
        !           202:   }
        !           203: }

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>