Annotation of embedaddon/php/ext/sqlite/libsqlite/src/table.c, revision 1.1.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>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to table.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / sqlite / libsqlite / src