Debian Codegraph @

ext/rbu/test_rbu.c

raw
1 /*
2 ** 2015 February 16
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 */
13
14 #include "sqlite3.h"
15
16 #if defined(SQLITE_TEST)
17 #if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_RBU)
18
19 #include "sqlite3rbu.h"
20 #include "tclsqlite.h"
21 #include <assert.h>
22 #include <string.h>
23
24 typedef struct TestRbu TestRbu;
25 struct TestRbu {
26 sqlite3rbu *pRbu;
27 Tcl_Interp *interp;
28 Tcl_Obj *xRename;
29 };
30
31 /* From main.c */
32 extern const char *sqlite3ErrName(int);
33 extern int sqlite3TestMakePointerStr(Tcl_Interp*, char*, void*);
34
35 void test_rbu_delta(sqlite3_context *pCtx, int nArg, sqlite3_value **apVal){
36 Tcl_Interp *interp = (Tcl_Interp*)sqlite3_user_data(pCtx);
37 Tcl_Obj *pScript;
38 int i;
39
40 pScript = Tcl_NewObj();
41 Tcl_IncrRefCount(pScript);
42 Tcl_ListObjAppendElement(0, pScript, Tcl_NewStringObj("rbu_delta", -1));
43 for(i=0; i<nArg; i++){
44 sqlite3_value *pIn = apVal[i];
45 const char *z = (const char*)sqlite3_value_text(pIn);
46 Tcl_ListObjAppendElement(0, pScript, Tcl_NewStringObj(z, -1));
47 }
48
49 if( TCL_OK==Tcl_EvalObjEx(interp, pScript, TCL_GLOBAL_ONLY) ){
50 const char *z = Tcl_GetStringResult(interp);
51 sqlite3_result_text(pCtx, z, -1, SQLITE_TRANSIENT);
52 }else{
53 Tcl_BackgroundError(interp);
54 }
55
56 Tcl_DecrRefCount(pScript);
57 }
58
59 static int xRenameCallback(void *pArg, const char *zOld, const char *zNew){
60 int rc = SQLITE_OK;
61 TestRbu *pTest = (TestRbu*)pArg;
62 Tcl_Obj *pEval = Tcl_DuplicateObj(pTest->xRename);
63
64 Tcl_IncrRefCount(pEval);
65 Tcl_ListObjAppendElement(pTest->interp, pEval, Tcl_NewStringObj(zOld, -1));
66 Tcl_ListObjAppendElement(pTest->interp, pEval, Tcl_NewStringObj(zNew, -1));
67
68 rc = Tcl_EvalObjEx(pTest->interp, pEval, TCL_GLOBAL_ONLY);
69 Tcl_DecrRefCount(pEval);
70
71 return rc ? SQLITE_IOERR : SQLITE_OK;
72 }
73
74 static int SQLITE_TCLAPI test_sqlite3rbu_cmd(
75 ClientData clientData,
76 Tcl_Interp *interp,
77 int objc,
78 Tcl_Obj *CONST objv[]
79 ){
80 int ret = TCL_OK;
81 TestRbu *pTest = (TestRbu*)clientData;
82 sqlite3rbu *pRbu = pTest->pRbu;
83 struct RbuCmd {
84 const char *zName;
85 int nArg;
86 const char *zUsage;
87 } aCmd[] = {
88 {"step", 2, ""}, /* 0 */
89 {"close", 2, ""}, /* 1 */
90 {"create_rbu_delta", 2, ""}, /* 2 */
91 {"savestate", 2, ""}, /* 3 */
92 {"dbMain_eval", 3, "SQL"}, /* 4 */
93 {"bp_progress", 2, ""}, /* 5 */
94 {"db", 3, "RBU"}, /* 6 */
95 {"state", 2, ""}, /* 7 */
96 {"progress", 2, ""}, /* 8 */
97 {"close_no_error", 2, ""}, /* 9 */
98 {"temp_size_limit", 3, "LIMIT"}, /* 10 */
99 {"temp_size", 2, ""}, /* 11 */
100 {"dbRbu_eval", 3, "SQL"}, /* 12 */
101 {"rename_handler", 3, "SCRIPT"},/* 13 */
102 {0,0,0}
103 };
104 int iCmd;
105
106 if( objc<2 ){
107 Tcl_WrongNumArgs(interp, 1, objv, "METHOD");
108 return TCL_ERROR;
109 }
110 ret = Tcl_GetIndexFromObjStruct(
111 interp, objv[1], aCmd, sizeof(aCmd[0]), "method", 0, &iCmd
112 );
113 if( ret ) return TCL_ERROR;
114 if( objc!=aCmd[iCmd].nArg ){
115 Tcl_WrongNumArgs(interp, 1, objv, aCmd[iCmd].zUsage);
116 return TCL_ERROR;
117 }
118
119 switch( iCmd ){
120 case 0: /* step */ {
121 int rc = sqlite3rbu_step(pRbu);
122 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
123 break;
124 }
125
126 case 9: /* close_no_error */
127 case 1: /* close */ {
128 char *zErrmsg = 0;
129 int rc;
130 Tcl_DeleteCommand(interp, Tcl_GetString(objv[0]));
131 if( iCmd==1 ){
132 rc = sqlite3rbu_close(pRbu, &zErrmsg);
133 }else{
134 rc = sqlite3rbu_close(pRbu, 0);
135 }
136 if( rc==SQLITE_OK || rc==SQLITE_DONE ){
137 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
138 assert( zErrmsg==0 );
139 }else{
140 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
141 if( zErrmsg ){
142 Tcl_AppendResult(interp, " - ", zErrmsg, NULL);
143 sqlite3_free(zErrmsg);
144 }
145 ret = TCL_ERROR;
146 }
147 if( pTest->xRename ) Tcl_DecrRefCount(pTest->xRename);
148 ckfree(pTest);
149 break;
150 }
151
152 case 2: /* create_rbu_delta */ {
153 sqlite3 *db = sqlite3rbu_db(pRbu, 0);
154 int rc = sqlite3_create_function(
155 db, "rbu_delta", -1, SQLITE_UTF8, (void*)interp, test_rbu_delta, 0, 0
156 );
157 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
158 ret = (rc==SQLITE_OK ? TCL_OK : TCL_ERROR);
159 break;
160 }
161
162 case 3: /* savestate */ {
163 int rc = sqlite3rbu_savestate(pRbu);
164 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
165 ret = (rc==SQLITE_OK ? TCL_OK : TCL_ERROR);
166 break;
167 }
168
169 case 12: /* dbRbu_eval */
170 case 4: /* dbMain_eval */ {
171 sqlite3 *db = sqlite3rbu_db(pRbu, (iCmd==12));
172 int rc = sqlite3_exec(db, Tcl_GetString(objv[2]), 0, 0, 0);
173 if( rc!=SQLITE_OK ){
174 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3_errmsg(db), -1));
175 ret = TCL_ERROR;
176 }
177 break;
178 }
179
180 case 5: /* bp_progress */ {
181 int one, two;
182 Tcl_Obj *pObj;
183 sqlite3rbu_bp_progress(pRbu, &one, &two);
184
185 pObj = Tcl_NewObj();
186 Tcl_ListObjAppendElement(interp, pObj, Tcl_NewIntObj(one));
187 Tcl_ListObjAppendElement(interp, pObj, Tcl_NewIntObj(two));
188 Tcl_SetObjResult(interp, pObj);
189 break;
190 }
191
192 case 6: /* db */ {
193 int bArg;
194 if( Tcl_GetBooleanFromObj(interp, objv[2], &bArg) ){
195 ret = TCL_ERROR;
196 }else{
197 char zBuf[50];
198 sqlite3 *db = sqlite3rbu_db(pRbu, bArg);
199 if( sqlite3TestMakePointerStr(interp, zBuf, (void*)db) ){
200 ret = TCL_ERROR;
201 }else{
202 Tcl_SetResult(interp, zBuf, TCL_VOLATILE);
203 }
204 }
205 break;
206 }
207 case 7: /* state */ {
208 const char *aRes[] = { 0, "oal", "move", "checkpoint", "done", "error" };
209 int eState = sqlite3rbu_state(pRbu);
210 assert( eState>0 && eState<=5 );
211 Tcl_SetResult(interp, (char*)aRes[eState], TCL_STATIC);
212 break;
213 }
214 case 8: /* progress */ {
215 sqlite3_int64 nStep = sqlite3rbu_progress(pRbu);
216 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(nStep));
217 break;
218 }
219
220 case 10: /* temp_size_limit */ {
221 sqlite3_int64 nLimit;
222 if( Tcl_GetWideIntFromObj(interp, objv[2], &nLimit) ){
223 ret = TCL_ERROR;
224 }else{
225 nLimit = sqlite3rbu_temp_size_limit(pRbu, nLimit);
226 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(nLimit));
227 }
228 break;
229 }
230 case 11: /* temp_size */ {
231 sqlite3_int64 sz = sqlite3rbu_temp_size(pRbu);
232 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(sz));
233 break;
234 }
235
236 case 13: /* rename_handler */ {
237 Tcl_Obj *pScript = objv[2];
238 assert( !sqlite3_stricmp(aCmd[13].zName, "rename_handler") );
239 if( Tcl_GetCharLength(pScript)==0 ){
240 sqlite3rbu_rename_handler(pRbu, 0, 0);
241 }else{
242 pTest->xRename = Tcl_DuplicateObj(pScript);
243 Tcl_IncrRefCount(pTest->xRename);
244 sqlite3rbu_rename_handler(pRbu, pTest, xRenameCallback);
245 }
246 break;
247 }
248
249 default: /* seems unlikely */
250 assert( !"cannot happen" );
251 break;
252 }
253
254 return ret;
255 }
256
257 static void createRbuWrapper(
258 Tcl_Interp *interp,
259 const char *zCmd,
260 sqlite3rbu *pRbu
261 ){
262 TestRbu *pTest = (TestRbu*)ckalloc(sizeof(TestRbu));
263 memset(pTest, 0, sizeof(TestRbu));
264 pTest->pRbu = pRbu;
265 pTest->interp = interp;
266 Tcl_CreateObjCommand(interp, zCmd, test_sqlite3rbu_cmd, (ClientData)pTest, 0);
267 }
268
269 /*
270 ** Tclcmd: sqlite3rbu CMD <target-db> <rbu-db> ?<state-db>?
271 */
272 static int SQLITE_TCLAPI test_sqlite3rbu(
273 ClientData clientData,
274 Tcl_Interp *interp,
275 int objc,
276 Tcl_Obj *CONST objv[]
277 ){
278 sqlite3rbu *pRbu = 0;
279 const char *zCmd;
280 const char *zTarget;
281 const char *zRbu;
282 const char *zStateDb = 0;
283
284 if( objc!=4 && objc!=5 ){
285 Tcl_WrongNumArgs(interp, 1, objv, "NAME TARGET-DB RBU-DB ?STATE-DB?");
286 return TCL_ERROR;
287 }
288 zCmd = Tcl_GetString(objv[1]);
289 zTarget = Tcl_GetString(objv[2]);
290 zRbu = Tcl_GetString(objv[3]);
291 if( objc==5 ) zStateDb = Tcl_GetString(objv[4]);
292
293 pRbu = sqlite3rbu_open(zTarget, zRbu, zStateDb);
294 createRbuWrapper(interp, zCmd, pRbu);
295 Tcl_SetObjResult(interp, objv[1]);
296 return TCL_OK;
297 }
298
299 /*
300 ** Tclcmd: sqlite3rbu_vacuum CMD <target-db> <state-db>
301 */
302 static int SQLITE_TCLAPI test_sqlite3rbu_vacuum(
303 ClientData clientData,
304 Tcl_Interp *interp,
305 int objc,
306 Tcl_Obj *CONST objv[]
307 ){
308 sqlite3rbu *pRbu = 0;
309 const char *zCmd;
310 const char *zTarget;
311 const char *zStateDb = 0;
312
313 if( objc!=3 && objc!=4 ){
314 Tcl_WrongNumArgs(interp, 1, objv, "NAME TARGET-DB ?STATE-DB?");
315 return TCL_ERROR;
316 }
317 zCmd = Tcl_GetString(objv[1]);
318 zTarget = Tcl_GetString(objv[2]);
319 if( objc==4 ) zStateDb = Tcl_GetString(objv[3]);
320 if( zStateDb && zStateDb[0]=='\0' ) zStateDb = 0;
321
322 pRbu = sqlite3rbu_vacuum(zTarget, zStateDb);
323 createRbuWrapper(interp, zCmd, pRbu);
324 Tcl_SetObjResult(interp, objv[1]);
325 return TCL_OK;
326 }
327
328 /*
329 ** Tclcmd: sqlite3rbu_create_vfs ?-default? NAME PARENT
330 */
331 static int SQLITE_TCLAPI test_sqlite3rbu_create_vfs(
332 ClientData clientData,
333 Tcl_Interp *interp,
334 int objc,
335 Tcl_Obj *CONST objv[]
336 ){
337 const char *zName;
338 const char *zParent;
339 int rc;
340
341 if( objc!=3 && objc!=4 ){
342 Tcl_WrongNumArgs(interp, 1, objv, "?-default? NAME PARENT");
343 return TCL_ERROR;
344 }
345
346 zName = Tcl_GetString(objv[objc-2]);
347 zParent = Tcl_GetString(objv[objc-1]);
348 if( zParent[0]=='\0' ) zParent = 0;
349
350 rc = sqlite3rbu_create_vfs(zName, zParent);
351 if( rc!=SQLITE_OK ){
352 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
353 return TCL_ERROR;
354 }else if( objc==4 ){
355 sqlite3_vfs *pVfs = sqlite3_vfs_find(zName);
356 sqlite3_vfs_register(pVfs, 1);
357 }
358
359 Tcl_ResetResult(interp);
360 return TCL_OK;
361 }
362
363 /*
364 ** Tclcmd: sqlite3rbu_destroy_vfs NAME
365 */
366 static int SQLITE_TCLAPI test_sqlite3rbu_destroy_vfs(
367 ClientData clientData,
368 Tcl_Interp *interp,
369 int objc,
370 Tcl_Obj *CONST objv[]
371 ){
372 const char *zName;
373
374 if( objc!=2 ){
375 Tcl_WrongNumArgs(interp, 1, objv, "NAME");
376 return TCL_ERROR;
377 }
378
379 zName = Tcl_GetString(objv[1]);
380 sqlite3rbu_destroy_vfs(zName);
381 return TCL_OK;
382 }
383
384 /*
385 ** Tclcmd: sqlite3rbu_internal_test
386 */
387 static int SQLITE_TCLAPI test_sqlite3rbu_internal_test(
388 ClientData clientData,
389 Tcl_Interp *interp,
390 int objc,
391 Tcl_Obj *CONST objv[]
392 ){
393 sqlite3 *db;
394
395 if( objc!=1 ){
396 Tcl_WrongNumArgs(interp, 1, objv, "");
397 return TCL_ERROR;
398 }
399
400 db = sqlite3rbu_db(0, 0);
401 if( db!=0 ){
402 Tcl_AppendResult(interp, "sqlite3rbu_db(0, 0)!=0", NULL);
403 return TCL_ERROR;
404 }
405
406 return TCL_OK;
407 }
408
409 int SqliteRbu_Init(Tcl_Interp *interp){
410 static struct {
411 char *zName;
412 Tcl_ObjCmdProc *xProc;
413 } aObjCmd[] = {
414 { "sqlite3rbu", test_sqlite3rbu },
415 { "sqlite3rbu_vacuum", test_sqlite3rbu_vacuum },
416 { "sqlite3rbu_create_vfs", test_sqlite3rbu_create_vfs },
417 { "sqlite3rbu_destroy_vfs", test_sqlite3rbu_destroy_vfs },
418 { "sqlite3rbu_internal_test", test_sqlite3rbu_internal_test },
419 };
420 int i;
421 for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){
422 Tcl_CreateObjCommand(interp, aObjCmd[i].zName, aObjCmd[i].xProc, 0, 0);
423 }
424 return TCL_OK;
425 }
426
427 #else
428 #include "tclsqlite.h"
429 int SqliteRbu_Init(Tcl_Interp *interp){ return TCL_OK; }
430 #endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_RBU) */
431 #endif /* defined(SQLITE_TEST) */