| /* |
| ** 2001 September 15 |
| ** |
| ** The author disclaims copyright to this source code. In place of |
| ** a legal notice, here is a blessing: |
| ** |
| ** May you do good and not evil. |
| ** May you find forgiveness for yourself and forgive others. |
| ** May you share freely, never taking more than you give. |
| ** |
| ************************************************************************* |
| ** This file contains the sqlite3_get_table() and sqlite3_free_table() |
| ** interface routines. These are just wrappers around the main |
| ** interface routine of sqlite3_exec(). |
| ** |
| ** These routines are in a separate files so that they will not be linked |
| ** if they are not used. |
| */ |
| #include "sqliteInt.h" |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #ifndef SQLITE_OMIT_GET_TABLE |
| |
| /* |
| ** This structure is used to pass data from sqlite3_get_table() through |
| ** to the callback function is uses to build the result. |
| */ |
| typedef struct TabResult { |
| char **azResult; /* Accumulated output */ |
| char *zErrMsg; /* Error message text, if an error occurs */ |
| int nAlloc; /* Slots allocated for azResult[] */ |
| int nRow; /* Number of rows in the result */ |
| int nColumn; /* Number of columns in the result */ |
| int nData; /* Slots used in azResult[]. (nRow+1)*nColumn */ |
| int rc; /* Return code from sqlite3_exec() */ |
| } TabResult; |
| |
| /* |
| ** This routine is called once for each row in the result table. Its job |
| ** is to fill in the TabResult structure appropriately, allocating new |
| ** memory as necessary. |
| */ |
| static int sqlite3_get_table_cb(void *pArg, int nCol, char **argv, char **colv){ |
| TabResult *p = (TabResult*)pArg; /* Result accumulator */ |
| int need; /* Slots needed in p->azResult[] */ |
| int i; /* Loop counter */ |
| char *z; /* A single column of result */ |
| |
| /* Make sure there is enough space in p->azResult to hold everything |
| ** we need to remember from this invocation of the callback. |
| */ |
| if( p->nRow==0 && argv!=0 ){ |
| need = nCol*2; |
| }else{ |
| need = nCol; |
| } |
| if( p->nData + need > p->nAlloc ){ |
| char **azNew; |
| p->nAlloc = p->nAlloc*2 + need; |
| azNew = sqlite3_realloc( p->azResult, sizeof(char*)*p->nAlloc ); |
| if( azNew==0 ) goto malloc_failed; |
| p->azResult = azNew; |
| } |
| |
| /* If this is the first row, then generate an extra row containing |
| ** the names of all columns. |
| */ |
| if( p->nRow==0 ){ |
| p->nColumn = nCol; |
| for(i=0; i<nCol; i++){ |
| z = sqlite3_mprintf("%s", colv[i]); |
| if( z==0 ) goto malloc_failed; |
| p->azResult[p->nData++] = z; |
| } |
| }else if( p->nColumn!=nCol ){ |
| sqlite3_free(p->zErrMsg); |
| p->zErrMsg = sqlite3_mprintf( |
| "sqlite3_get_table() called with two or more incompatible queries" |
| ); |
| p->rc = SQLITE_ERROR; |
| return 1; |
| } |
| |
| /* Copy over the row data |
| */ |
| if( argv!=0 ){ |
| for(i=0; i<nCol; i++){ |
| if( argv[i]==0 ){ |
| z = 0; |
| }else{ |
| int n = sqlite3Strlen30(argv[i])+1; |
| z = sqlite3_malloc( n ); |
| if( z==0 ) goto malloc_failed; |
| memcpy(z, argv[i], n); |
| } |
| p->azResult[p->nData++] = z; |
| } |
| p->nRow++; |
| } |
| return 0; |
| |
| malloc_failed: |
| p->rc = SQLITE_NOMEM; |
| return 1; |
| } |
| |
| /* |
| ** Query the database. But instead of invoking a callback for each row, |
| ** malloc() for space to hold the result and return the entire results |
| ** at the conclusion of the call. |
| ** |
| ** The result that is written to ***pazResult is held in memory obtained |
| ** from malloc(). But the caller cannot free this memory directly. |
| ** Instead, the entire table should be passed to sqlite3_free_table() when |
| ** the calling procedure is finished using it. |
| */ |
| int sqlite3_get_table( |
| sqlite3 *db, /* The database on which the SQL executes */ |
| const char *zSql, /* The SQL to be executed */ |
| char ***pazResult, /* Write the result table here */ |
| int *pnRow, /* Write the number of rows in the result here */ |
| int *pnColumn, /* Write the number of columns of result here */ |
| char **pzErrMsg /* Write error messages here */ |
| ){ |
| int rc; |
| TabResult res; |
| |
| *pazResult = 0; |
| if( pnColumn ) *pnColumn = 0; |
| if( pnRow ) *pnRow = 0; |
| if( pzErrMsg ) *pzErrMsg = 0; |
| res.zErrMsg = 0; |
| res.nRow = 0; |
| res.nColumn = 0; |
| res.nData = 1; |
| res.nAlloc = 20; |
| res.rc = SQLITE_OK; |
| res.azResult = sqlite3_malloc(sizeof(char*)*res.nAlloc ); |
| if( res.azResult==0 ){ |
| db->errCode = SQLITE_NOMEM; |
| return SQLITE_NOMEM; |
| } |
| res.azResult[0] = 0; |
| rc = sqlite3_exec(db, zSql, sqlite3_get_table_cb, &res, pzErrMsg); |
| assert( sizeof(res.azResult[0])>= sizeof(res.nData) ); |
| res.azResult[0] = SQLITE_INT_TO_PTR(res.nData); |
| if( (rc&0xff)==SQLITE_ABORT ){ |
| sqlite3_free_table(&res.azResult[1]); |
| if( res.zErrMsg ){ |
| if( pzErrMsg ){ |
| sqlite3_free(*pzErrMsg); |
| *pzErrMsg = sqlite3_mprintf("%s",res.zErrMsg); |
| } |
| sqlite3_free(res.zErrMsg); |
| } |
| db->errCode = res.rc; /* Assume 32-bit assignment is atomic */ |
| return res.rc; |
| } |
| sqlite3_free(res.zErrMsg); |
| if( rc!=SQLITE_OK ){ |
| sqlite3_free_table(&res.azResult[1]); |
| return rc; |
| } |
| if( res.nAlloc>res.nData ){ |
| char **azNew; |
| azNew = sqlite3_realloc( res.azResult, sizeof(char*)*res.nData ); |
| if( azNew==0 ){ |
| sqlite3_free_table(&res.azResult[1]); |
| db->errCode = SQLITE_NOMEM; |
| return SQLITE_NOMEM; |
| } |
| res.azResult = azNew; |
| } |
| *pazResult = &res.azResult[1]; |
| if( pnColumn ) *pnColumn = res.nColumn; |
| if( pnRow ) *pnRow = res.nRow; |
| return rc; |
| } |
| |
| /* |
| ** This routine frees the space the sqlite3_get_table() malloced. |
| */ |
| void sqlite3_free_table( |
| char **azResult /* Result returned from from sqlite3_get_table() */ |
| ){ |
| if( azResult ){ |
| int i, n; |
| azResult--; |
| assert( azResult!=0 ); |
| n = SQLITE_PTR_TO_INT(azResult[0]); |
| for(i=1; i<n; i++){ if( azResult[i] ) sqlite3_free(azResult[i]); } |
| sqlite3_free(azResult); |
| } |
| } |
| |
| #endif /* SQLITE_OMIT_GET_TABLE */ |