src/table.c

   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 sqlite3_get_table() and sqlite3_free_table()
  13 ** interface routines.  These are just wrappers around the main
  14 ** interface routine of sqlite3_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 "sqliteInt.h"
  20
  21 #ifndef SQLITE_OMIT_GET_TABLE
  22
  23 /*
  24 ** This structure is used to pass data from sqlite3_get_table() through
  25 ** to the callback function is uses to build the result.
  26 */
  27 typedef struct TabResult {
  28   char **azResult;   /* Accumulated output */
  29   char *zErrMsg;     /* Error message text, if an error occurs */
  30   u32 nAlloc;        /* Slots allocated for azResult[] */
  31   u32 nRow;          /* Number of rows in the result */
  32   u32 nColumn;       /* Number of columns in the result */
  33   u32 nData;         /* Slots used in azResult[].  (nRow+1)*nColumn */
  34   int rc;            /* Return code from sqlite3_exec() */
  35 } TabResult;
  36
  37 /*
  38 ** This routine is called once for each row in the result table.  Its job
  39 ** is to fill in the TabResult structure appropriately, allocating new
  40 ** memory as necessary.
  41 */
  42 static int sqlite3_get_table_cb(void *pArg, int nCol, char **argv, char **colv){
  43   TabResult *p = (TabResult*)pArg;  /* Result accumulator */
  44   int need;                         /* Slots needed in p->azResult[] */
  45   int i;                            /* Loop counter */
  46   char *z;                          /* A single column of result */
  47
  48   /* Make sure there is enough space in p->azResult to hold everything
  49   ** we need to remember from this invocation of the callback.
  50   */
  51   if( p->nRow==0 && argv!=0 ){
  52     need = nCol*2;
  53   }else{
  54     need = nCol;
  55   }
  56   if( p->nData + need > p->nAlloc ){
  57     char **azNew;
  58     p->nAlloc = p->nAlloc*2 + need;
  59     azNew = sqlite3Realloc( p->azResult, sizeof(char*)*p->nAlloc );
  60     if( azNew==0 ) goto malloc_failed;
  61     p->azResult = azNew;
  62   }
  63
  64   /* If this is the first row, then generate an extra row containing
  65   ** the names of all columns.
  66   */
  67   if( p->nRow==0 ){
  68     p->nColumn = nCol;
  69     for(i=0; i<nCol; i++){
  70       z = sqlite3_mprintf("%s", colv[i]);
  71       if( z==0 ) goto malloc_failed;
  72       p->azResult[p->nData++] = z;
  73     }
  74   }else if( (int)p->nColumn!=nCol ){
  75     sqlite3_free(p->zErrMsg);
  76     p->zErrMsg = sqlite3_mprintf(
  77        "sqlite3_get_table() called with two or more incompatible queries"
  78     );
  79     p->rc = SQLITE_ERROR;
  80     return 1;
  81   }
  82
  83   /* Copy over the row data
  84   */
  85   if( argv!=0 ){
  86     for(i=0; i<nCol; i++){
  87       if( argv[i]==0 ){
  88         z = 0;
  89       }else{
  90         int n = sqlite3Strlen30(argv[i])+1;
  91         z = sqlite3_malloc64( n );
  92         if( z==0 ) goto malloc_failed;
  93         memcpy(z, argv[i], n);
  94       }
  95       p->azResult[p->nData++] = z;
  96     }
  97     p->nRow++;
  98   }
  99   return 0;
 100
 101 malloc_failed:
 102   p->rc = SQLITE_NOMEM_BKPT;
 103   return 1;
 104 }
 105
 106 /*
 107 ** Query the database.  But instead of invoking a callback for each row,
 108 ** malloc() for space to hold the result and return the entire results
 109 ** at the conclusion of the call.
 110 **
 111 ** The result that is written to ***pazResult is held in memory obtained
 112 ** from malloc().  But the caller cannot free this memory directly.
 113 ** Instead, the entire table should be passed to sqlite3_free_table() when
 114 ** the calling procedure is finished using it.
 115 */
 116 int sqlite3_get_table(
 117   sqlite3 *db,                /* The database on which the SQL executes */
 118   const char *zSql,           /* The SQL to be executed */
 119   char ***pazResult,          /* Write the result table here */
 120   int *pnRow,                 /* Write the number of rows in the result here */
 121   int *pnColumn,              /* Write the number of columns of result here */
 122   char **pzErrMsg             /* Write error messages here */
 123 ){
 124   int rc;
 125   TabResult res;
 126
 127 #ifdef SQLITE_ENABLE_API_ARMOR
 128   if( !sqlite3SafetyCheckOk(db) || pazResult==0 ) return SQLITE_MISUSE_BKPT;
 129 #endif
 130   *pazResult = 0;
 131   if( pnColumn ) *pnColumn = 0;
 132   if( pnRow ) *pnRow = 0;
 133   if( pzErrMsg ) *pzErrMsg = 0;
 134   res.zErrMsg = 0;
 135   res.nRow = 0;
 136   res.nColumn = 0;
 137   res.nData = 1;
 138   res.nAlloc = 20;
 139   res.rc = SQLITE_OK;
 140   res.azResult = sqlite3_malloc64(sizeof(char*)*res.nAlloc );
 141   if( res.azResult==0 ){
 142      db->errCode = SQLITE_NOMEM;
 143      return SQLITE_NOMEM_BKPT;
 144   }
 145   res.azResult[0] = 0;
 146   rc = sqlite3_exec(db, zSql, sqlite3_get_table_cb, &res, pzErrMsg);
 147   assert( sizeof(res.azResult[0])>= sizeof(res.nData) );
 148   res.azResult[0] = SQLITE_INT_TO_PTR(res.nData);
 149   if( (rc&0xff)==SQLITE_ABORT ){
 150     sqlite3_free_table(&res.azResult[1]);
 151     if( res.zErrMsg ){
 152       if( pzErrMsg ){
 153         sqlite3_free(*pzErrMsg);
 154         *pzErrMsg = sqlite3_mprintf("%s",res.zErrMsg);
 155       }
 156       sqlite3_free(res.zErrMsg);
 157     }
 158     db->errCode = res.rc;  /* Assume 32-bit assignment is atomic */
 159     return res.rc;
 160   }
 161   sqlite3_free(res.zErrMsg);
 162   if( rc!=SQLITE_OK ){
 163     sqlite3_free_table(&res.azResult[1]);
 164     return rc;
 165   }
 166   if( res.nAlloc>res.nData ){
 167     char **azNew;
 168     azNew = sqlite3Realloc( res.azResult, sizeof(char*)*res.nData );
 169     if( azNew==0 ){
 170       sqlite3_free_table(&res.azResult[1]);
 171       db->errCode = SQLITE_NOMEM;
 172       return SQLITE_NOMEM_BKPT;
 173     }
 174     res.azResult = azNew;
 175   }
 176   *pazResult = &res.azResult[1];
 177   if( pnColumn ) *pnColumn = res.nColumn;
 178   if( pnRow ) *pnRow = res.nRow;
 179   return rc;
 180 }
 181
 182 /*
 183 ** This routine frees the space the sqlite3_get_table() malloced.
 184 */
 185 void sqlite3_free_table(
 186   char **azResult            /* Result returned from sqlite3_get_table() */
 187 ){
 188   if( azResult ){
 189     int i, n;
 190     azResult--;
 191     assert( azResult!=0 );
 192     n = SQLITE_PTR_TO_INT(azResult[0]);
 193     for(i=1; i<n; i++){ if( azResult[i] ) sqlite3_free(azResult[i]); }
 194     sqlite3_free(azResult);
 195   }
 196 }
 197
 198 #endif /* SQLITE_OMIT_GET_TABLE */