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 */
sqlite_get_table_cb(void * pArg,int nCol,char ** argv,char ** colv)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 */
sqlite_get_table(sqlite * db,const char * zSql,char *** pazResult,int * pnRow,int * pnColumn,char ** pzErrMsg)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 */
sqlite_free_table(char ** azResult)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 }
204
