4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
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.
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().
16 ** These routines are in a separate files so that they will not be linked
17 ** if they are not used.
19 #include "sqliteInt.h"
23 #ifndef SQLITE_OMIT_GET_TABLE
26 ** This structure is used to pass data from sqlite3_get_table() through
27 ** to the callback function is uses to build the result.
29 typedef struct TabResult
{
30 char **azResult
; /* Accumulated output */
31 char *zErrMsg
; /* Error message text, if an error occurs */
32 u32 nAlloc
; /* Slots allocated for azResult[] */
33 u32 nRow
; /* Number of rows in the result */
34 u32 nColumn
; /* Number of columns in the result */
35 u32 nData
; /* Slots used in azResult[]. (nRow+1)*nColumn */
36 int rc
; /* Return code from sqlite3_exec() */
40 ** This routine is called once for each row in the result table. Its job
41 ** is to fill in the TabResult structure appropriately, allocating new
42 ** memory as necessary.
44 static int sqlite3_get_table_cb(void *pArg
, int nCol
, char **argv
, char **colv
){
45 TabResult
*p
= (TabResult
*)pArg
; /* Result accumulator */
46 int need
; /* Slots needed in p->azResult[] */
47 int i
; /* Loop counter */
48 char *z
; /* A single column of result */
50 /* Make sure there is enough space in p->azResult to hold everything
51 ** we need to remember from this invocation of the callback.
53 if( p
->nRow
==0 && argv
!=0 ){
58 if( p
->nData
+ need
> p
->nAlloc
){
60 p
->nAlloc
= p
->nAlloc
*2 + need
;
61 azNew
= sqlite3_realloc64( p
->azResult
, sizeof(char*)*p
->nAlloc
);
62 if( azNew
==0 ) goto malloc_failed
;
66 /* If this is the first row, then generate an extra row containing
67 ** the names of all columns.
71 for(i
=0; i
<nCol
; i
++){
72 z
= sqlite3_mprintf("%s", colv
[i
]);
73 if( z
==0 ) goto malloc_failed
;
74 p
->azResult
[p
->nData
++] = z
;
76 }else if( (int)p
->nColumn
!=nCol
){
77 sqlite3_free(p
->zErrMsg
);
78 p
->zErrMsg
= sqlite3_mprintf(
79 "sqlite3_get_table() called with two or more incompatible queries"
85 /* Copy over the row data
88 for(i
=0; i
<nCol
; i
++){
92 int n
= sqlite3Strlen30(argv
[i
])+1;
93 z
= sqlite3_malloc64( n
);
94 if( z
==0 ) goto malloc_failed
;
95 memcpy(z
, argv
[i
], n
);
97 p
->azResult
[p
->nData
++] = z
;
104 p
->rc
= SQLITE_NOMEM_BKPT
;
109 ** Query the database. But instead of invoking a callback for each row,
110 ** malloc() for space to hold the result and return the entire results
111 ** at the conclusion of the call.
113 ** The result that is written to ***pazResult is held in memory obtained
114 ** from malloc(). But the caller cannot free this memory directly.
115 ** Instead, the entire table should be passed to sqlite3_free_table() when
116 ** the calling procedure is finished using it.
118 int sqlite3_get_table(
119 sqlite3
*db
, /* The database on which the SQL executes */
120 const char *zSql
, /* The SQL to be executed */
121 char ***pazResult
, /* Write the result table here */
122 int *pnRow
, /* Write the number of rows in the result here */
123 int *pnColumn
, /* Write the number of columns of result here */
124 char **pzErrMsg
/* Write error messages here */
129 #ifdef SQLITE_ENABLE_API_ARMOR
130 if( !sqlite3SafetyCheckOk(db
) || pazResult
==0 ) return SQLITE_MISUSE_BKPT
;
133 if( pnColumn
) *pnColumn
= 0;
134 if( pnRow
) *pnRow
= 0;
135 if( pzErrMsg
) *pzErrMsg
= 0;
142 res
.azResult
= sqlite3_malloc64(sizeof(char*)*res
.nAlloc
);
143 if( res
.azResult
==0 ){
144 db
->errCode
= SQLITE_NOMEM
;
145 return SQLITE_NOMEM_BKPT
;
148 rc
= sqlite3_exec(db
, zSql
, sqlite3_get_table_cb
, &res
, pzErrMsg
);
149 assert( sizeof(res
.azResult
[0])>= sizeof(res
.nData
) );
150 res
.azResult
[0] = SQLITE_INT_TO_PTR(res
.nData
);
151 if( (rc
&0xff)==SQLITE_ABORT
){
152 sqlite3_free_table(&res
.azResult
[1]);
155 sqlite3_free(*pzErrMsg
);
156 *pzErrMsg
= sqlite3_mprintf("%s",res
.zErrMsg
);
158 sqlite3_free(res
.zErrMsg
);
160 db
->errCode
= res
.rc
; /* Assume 32-bit assignment is atomic */
163 sqlite3_free(res
.zErrMsg
);
165 sqlite3_free_table(&res
.azResult
[1]);
168 if( res
.nAlloc
>res
.nData
){
170 azNew
= sqlite3_realloc64( res
.azResult
, sizeof(char*)*res
.nData
);
172 sqlite3_free_table(&res
.azResult
[1]);
173 db
->errCode
= SQLITE_NOMEM
;
174 return SQLITE_NOMEM_BKPT
;
176 res
.azResult
= azNew
;
178 *pazResult
= &res
.azResult
[1];
179 if( pnColumn
) *pnColumn
= res
.nColumn
;
180 if( pnRow
) *pnRow
= res
.nRow
;
185 ** This routine frees the space the sqlite3_get_table() malloced.
187 void sqlite3_free_table(
188 char **azResult
/* Result returned from sqlite3_get_table() */
193 assert( azResult
!=0 );
194 n
= SQLITE_PTR_TO_INT(azResult
[0]);
195 for(i
=1; i
<n
; i
++){ if( azResult
[i
] ) sqlite3_free(azResult
[i
]); }
196 sqlite3_free(azResult
);
200 #endif /* SQLITE_OMIT_GET_TABLE */