Debian Codegraph @

ext/session/test_session.c

raw
1
2 #if defined(SQLITE_TEST) && defined(SQLITE_ENABLE_SESSION) \
3 && defined(SQLITE_ENABLE_PREUPDATE_HOOK)
4
5 #include "sqlite3session.h"
6 #include <assert.h>
7 #include <string.h>
8 #include "tclsqlite.h"
9
10 #include <stdlib.h>
11
12 #ifndef SQLITE_AMALGAMATION
13 typedef unsigned char u8;
14 #endif
15
16 extern const char *sqlite3ErrName(int);
17
18 typedef struct TestSession TestSession;
19 struct TestSession {
20 sqlite3_session *pSession;
21 Tcl_Interp *interp;
22 Tcl_Obj *pFilterScript;
23 };
24
25 typedef struct TestStreamInput TestStreamInput;
26 struct TestStreamInput {
27 int nStream; /* Maximum chunk size */
28 unsigned char *aData; /* Pointer to buffer containing data */
29 int nData; /* Size of buffer aData in bytes */
30 int iData; /* Bytes of data already read by sessions */
31 };
32
33 /*
34 ** Extract an sqlite3* db handle from the object passed as the second
35 ** argument. If successful, set *pDb to point to the db handle and return
36 ** TCL_OK. Otherwise, return TCL_ERROR.
37 */
38 static int dbHandleFromObj(Tcl_Interp *interp, Tcl_Obj *pObj, sqlite3 **pDb){
39 Tcl_CmdInfo info;
40 if( 0==Tcl_GetCommandInfo(interp, Tcl_GetString(pObj), &info) ){
41 Tcl_AppendResult(interp, "no such handle: ", Tcl_GetString(pObj), NULL);
42 return TCL_ERROR;
43 }
44
45 *pDb = *(sqlite3 **)info.objClientData;
46 return TCL_OK;
47 }
48
49 /*************************************************************************
50 ** The following code is copied byte-for-byte from the sessions module
51 ** documentation. It is used by some of the sessions modules tests to
52 ** ensure that the example in the documentation does actually work.
53 */
54 /*
55 ** Argument zSql points to a buffer containing an SQL script to execute
56 ** against the database handle passed as the first argument. As well as
57 ** executing the SQL script, this function collects a changeset recording
58 ** all changes made to the "main" database file. Assuming no error occurs,
59 ** output variables (*ppChangeset) and (*pnChangeset) are set to point
60 ** to a buffer containing the changeset and the size of the changeset in
61 ** bytes before returning SQLITE_OK. In this case it is the responsibility
62 ** of the caller to eventually free the changeset blob by passing it to
63 ** the sqlite3_free function.
64 **
65 ** Or, if an error does occur, return an SQLite error code. The final
66 ** value of (*pChangeset) and (*pnChangeset) are undefined in this case.
67 */
68 int sql_exec_changeset(
69 sqlite3 *db, /* Database handle */
70 const char *zSql, /* SQL script to execute */
71 int *pnChangeset, /* OUT: Size of changeset blob in bytes */
72 void **ppChangeset /* OUT: Pointer to changeset blob */
73 ){
74 sqlite3_session *pSession = 0;
75 int rc;
76 int val = 1;
77
78 /* Create a new session object */
79 rc = sqlite3session_create(db, "main", &pSession);
80 sqlite3session_object_config(pSession, SQLITE_SESSION_OBJCONFIG_ROWID, &val);
81
82 /* Configure the session object to record changes to all tables */
83 if( rc==SQLITE_OK ) rc = sqlite3session_attach(pSession, NULL);
84
85 /* Execute the SQL script */
86 if( rc==SQLITE_OK ) rc = sqlite3_exec(db, zSql, 0, 0, 0);
87
88 /* Collect the changeset */
89 if( rc==SQLITE_OK ){
90 rc = sqlite3session_changeset(pSession, pnChangeset, ppChangeset);
91 }
92
93 /* Delete the session object */
94 sqlite3session_delete(pSession);
95
96 return rc;
97 }
98 /************************************************************************/
99
100
101 #ifdef SQLITE_DEBUG
102 static int sqlite3_test_changeset(int, void *, char **);
103 static void assert_changeset_is_ok(int n, void *p){
104 char *z = 0;
105 (void)sqlite3_test_changeset(n, p, &z);
106 assert( z==0 );
107 }
108 #else
109 # define assert_changeset_is_ok(n,p)
110 #endif
111
112 /*
113 ** Tclcmd: sql_exec_changeset DB SQL
114 */
115 static int SQLITE_TCLAPI test_sql_exec_changeset(
116 void * clientData,
117 Tcl_Interp *interp,
118 int objc,
119 Tcl_Obj *CONST objv[]
120 ){
121 const char *zSql;
122 sqlite3 *db;
123 void *pChangeset;
124 int nChangeset;
125 int rc;
126
127 if( objc!=3 ){
128 Tcl_WrongNumArgs(interp, 1, objv, "DB SQL");
129 return TCL_ERROR;
130 }
131 if( dbHandleFromObj(interp, objv[1], &db) ) return TCL_ERROR;
132 zSql = (const char*)Tcl_GetString(objv[2]);
133
134 rc = sql_exec_changeset(db, zSql, &nChangeset, &pChangeset);
135 if( rc!=SQLITE_OK ){
136 Tcl_ResetResult(interp);
137 Tcl_AppendResult(interp, "error in sql_exec_changeset()", NULL);
138 return TCL_ERROR;
139 }
140
141 assert_changeset_is_ok(nChangeset, pChangeset);
142 Tcl_SetObjResult(interp, Tcl_NewByteArrayObj(pChangeset, nChangeset));
143 sqlite3_free(pChangeset);
144 return TCL_OK;
145 }
146
147
148
149 #define SESSION_STREAM_TCL_VAR "sqlite3session_streams"
150
151 /*
152 ** Attempt to find the global variable zVar within interpreter interp
153 ** and extract an integer value from it. Return this value.
154 **
155 ** If the named variable cannot be found, or if it cannot be interpreted
156 ** as a integer, return 0.
157 */
158 static int test_tcl_integer(Tcl_Interp *interp, const char *zVar){
159 Tcl_Obj *pObj;
160 int iVal = 0;
161 Tcl_Obj *pName = Tcl_NewStringObj(zVar, -1);
162 Tcl_IncrRefCount(pName);
163 pObj = Tcl_ObjGetVar2(interp, pName, 0, TCL_GLOBAL_ONLY);
164 Tcl_DecrRefCount(pName);
165 if( pObj ) Tcl_GetIntFromObj(0, pObj, &iVal);
166 return iVal;
167 }
168
169 static int test_session_error(Tcl_Interp *interp, int rc, char *zErr){
170 extern const char *sqlite3ErrName(int);
171 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
172 if( zErr ){
173 Tcl_AppendResult(interp, " - ", zErr, NULL);
174 sqlite3_free(zErr);
175 }
176 return TCL_ERROR;
177 }
178
179 static int test_table_filter(void *pCtx, const char *zTbl){
180 TestSession *p = (TestSession*)pCtx;
181 Tcl_Obj *pEval;
182 int rc;
183 int bRes = 0;
184
185 pEval = Tcl_DuplicateObj(p->pFilterScript);
186 Tcl_IncrRefCount(pEval);
187 rc = Tcl_ListObjAppendElement(p->interp, pEval, Tcl_NewStringObj(zTbl, -1));
188 if( rc==TCL_OK ){
189 rc = Tcl_EvalObjEx(p->interp, pEval, TCL_EVAL_GLOBAL);
190 }
191 if( rc==TCL_OK ){
192 rc = Tcl_GetBooleanFromObj(p->interp, Tcl_GetObjResult(p->interp), &bRes);
193 }
194 if( rc!=TCL_OK ){
195 /* printf("error: %s\n", Tcl_GetStringResult(p->interp)); */
196 Tcl_BackgroundError(p->interp);
197 }
198 Tcl_DecrRefCount(pEval);
199
200 return bRes;
201 }
202
203 struct TestSessionsBlob {
204 void *p;
205 int n;
206 };
207 typedef struct TestSessionsBlob TestSessionsBlob;
208
209 static int testStreamOutput(
210 void *pCtx,
211 const void *pData,
212 int nData
213 ){
214 TestSessionsBlob *pBlob = (TestSessionsBlob*)pCtx;
215 char *pNew;
216
217 assert( nData>0 );
218 pNew = (char*)sqlite3_realloc(pBlob->p, pBlob->n + nData);
219 if( pNew==0 ){
220 return SQLITE_NOMEM;
221 }
222 pBlob->p = (void*)pNew;
223 memcpy(&pNew[pBlob->n], pData, nData);
224 pBlob->n += nData;
225 return SQLITE_OK;
226 }
227
228 /*
229 ** Tclcmd: $session attach TABLE
230 ** $session changeset
231 ** $session delete
232 ** $session enable BOOL
233 ** $session indirect INTEGER
234 ** $session patchset
235 ** $session table_filter SCRIPT
236 */
237 static int SQLITE_TCLAPI test_session_cmd(
238 void *clientData,
239 Tcl_Interp *interp,
240 int objc,
241 Tcl_Obj *CONST objv[]
242 ){
243 TestSession *p = (TestSession*)clientData;
244 sqlite3_session *pSession = p->pSession;
245 static struct SessionSubcmd {
246 const char *zSub;
247 int nArg;
248 const char *zMsg;
249 int iSub;
250 } aSub[] = {
251 { "attach", 1, "TABLE", }, /* 0 */
252 { "changeset", 0, "", }, /* 1 */
253 { "delete", 0, "", }, /* 2 */
254 { "enable", 1, "BOOL", }, /* 3 */
255 { "indirect", 1, "BOOL", }, /* 4 */
256 { "isempty", 0, "", }, /* 5 */
257 { "table_filter", 1, "SCRIPT", }, /* 6 */
258 { "patchset", 0, "", }, /* 7 */
259 { "diff", 2, "FROMDB TBL", }, /* 8 */
260 { "memory_used", 0, "", }, /* 9 */
261 { "changeset_size", 0, "", }, /* 10 */
262 { "object_config", 2, "OPTION INTEGER", }, /* 11 */
263 { 0 }
264 };
265 int iSub;
266 int rc;
267
268 if( objc<2 ){
269 Tcl_WrongNumArgs(interp, 1, objv, "SUBCOMMAND ...");
270 return TCL_ERROR;
271 }
272 rc = Tcl_GetIndexFromObjStruct(interp,
273 objv[1], aSub, sizeof(aSub[0]), "sub-command", 0, &iSub
274 );
275 if( rc!=TCL_OK ) return rc;
276 if( objc!=2+aSub[iSub].nArg ){
277 Tcl_WrongNumArgs(interp, 2, objv, aSub[iSub].zMsg);
278 return TCL_ERROR;
279 }
280
281 switch( iSub ){
282 case 0: { /* attach */
283 char *zArg = Tcl_GetString(objv[2]);
284 if( zArg[0]=='*' && zArg[1]=='\0' ) zArg = 0;
285 rc = sqlite3session_attach(pSession, zArg);
286 if( rc!=SQLITE_OK ){
287 return test_session_error(interp, rc, 0);
288 }
289 break;
290 }
291
292 case 7: /* patchset */
293 case 1: { /* changeset */
294 TestSessionsBlob o = {0, 0};
295 if( test_tcl_integer(interp, SESSION_STREAM_TCL_VAR) ){
296 void *pCtx = (void*)&o;
297 if( iSub==7 ){
298 rc = sqlite3session_patchset_strm(pSession, testStreamOutput, pCtx);
299 }else{
300 rc = sqlite3session_changeset_strm(pSession, testStreamOutput, pCtx);
301 }
302 }else{
303 if( iSub==7 ){
304 rc = sqlite3session_patchset(pSession, &o.n, &o.p);
305 }else{
306 rc = sqlite3session_changeset(pSession, &o.n, &o.p);
307 }
308 }
309 if( rc==SQLITE_OK ){
310 assert_changeset_is_ok(o.n, o.p);
311 Tcl_SetObjResult(interp, Tcl_NewByteArrayObj(o.p, o.n));
312 }
313 sqlite3_free(o.p);
314 if( rc!=SQLITE_OK ){
315 return test_session_error(interp, rc, 0);
316 }
317 break;
318 }
319
320 case 2: /* delete */
321 Tcl_DeleteCommand(interp, Tcl_GetString(objv[0]));
322 break;
323
324 case 3: { /* enable */
325 int val;
326 if( Tcl_GetIntFromObj(interp, objv[2], &val) ) return TCL_ERROR;
327 val = sqlite3session_enable(pSession, val);
328 Tcl_SetObjResult(interp, Tcl_NewBooleanObj(val));
329 break;
330 }
331
332 case 4: { /* indirect */
333 int val;
334 if( Tcl_GetIntFromObj(interp, objv[2], &val) ) return TCL_ERROR;
335 val = sqlite3session_indirect(pSession, val);
336 Tcl_SetObjResult(interp, Tcl_NewBooleanObj(val));
337 break;
338 }
339
340 case 5: { /* isempty */
341 int val;
342 val = sqlite3session_isempty(pSession);
343 Tcl_SetObjResult(interp, Tcl_NewBooleanObj(val));
344 break;
345 }
346
347 case 6: { /* table_filter */
348 if( p->pFilterScript ) Tcl_DecrRefCount(p->pFilterScript);
349 p->interp = interp;
350 p->pFilterScript = Tcl_DuplicateObj(objv[2]);
351 Tcl_IncrRefCount(p->pFilterScript);
352 sqlite3session_table_filter(pSession, test_table_filter, clientData);
353 break;
354 }
355
356 case 8: { /* diff */
357 char *zErr = 0;
358 rc = sqlite3session_diff(pSession,
359 Tcl_GetString(objv[2]),
360 Tcl_GetString(objv[3]),
361 &zErr
362 );
363 assert( rc!=SQLITE_OK || zErr==0 );
364 if( rc ){
365 return test_session_error(interp, rc, zErr);
366 }
367 break;
368 }
369
370 case 9: { /* memory_used */
371 sqlite3_int64 nMalloc = sqlite3session_memory_used(pSession);
372 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(nMalloc));
373 break;
374 }
375
376 case 10: {
377 sqlite3_int64 nSize = sqlite3session_changeset_size(pSession);
378 Tcl_SetObjResult(interp, Tcl_NewWideIntObj(nSize));
379 break;
380 }
381 case 11: { /* object_config */
382 struct ObjConfOpt {
383 const char *zName;
384 int opt;
385 } aOpt[] = {
386 { "size", SQLITE_SESSION_OBJCONFIG_SIZE },
387 { "rowid", SQLITE_SESSION_OBJCONFIG_ROWID },
388 { 0, 0 }
389 };
390 int sz = (int)sizeof(aOpt[0]);
391
392 int iArg;
393 Tcl_Size iOpt;
394 if( Tcl_GetIndexFromObjStruct(interp,objv[2],aOpt,sz,"option",0,&iOpt) ){
395 return TCL_ERROR;
396 }
397 if( Tcl_GetIntFromObj(interp, objv[3], &iArg) ){
398 return TCL_ERROR;
399 }
400 rc = sqlite3session_object_config(pSession, aOpt[iOpt].opt, &iArg);
401 if( rc!=SQLITE_OK ){
402 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
403 }else{
404 Tcl_SetObjResult(interp, Tcl_NewIntObj(iArg));
405 }
406 break;
407 }
408 }
409
410 return TCL_OK;
411 }
412
413 static void SQLITE_TCLAPI test_session_del(void *clientData){
414 TestSession *p = (TestSession*)clientData;
415 if( p->pFilterScript ) Tcl_DecrRefCount(p->pFilterScript);
416 sqlite3session_delete(p->pSession);
417 ckfree((char*)p);
418 }
419
420 /*
421 ** Tclcmd: sqlite3session CMD DB-HANDLE DB-NAME
422 */
423 static int SQLITE_TCLAPI test_sqlite3session(
424 void * clientData,
425 Tcl_Interp *interp,
426 int objc,
427 Tcl_Obj *CONST objv[]
428 ){
429 sqlite3 *db;
430 Tcl_CmdInfo info;
431 int rc; /* sqlite3session_create() return code */
432 TestSession *p; /* New wrapper object */
433 int iArg = -1;
434
435 if( objc!=4 ){
436 Tcl_WrongNumArgs(interp, 1, objv, "CMD DB-HANDLE DB-NAME");
437 return TCL_ERROR;
438 }
439
440 if( 0==Tcl_GetCommandInfo(interp, Tcl_GetString(objv[2]), &info) ){
441 Tcl_AppendResult(interp, "no such handle: ", Tcl_GetString(objv[2]), NULL);
442 return TCL_ERROR;
443 }
444 db = *(sqlite3 **)info.objClientData;
445
446 p = (TestSession*)ckalloc(sizeof(TestSession));
447 memset(p, 0, sizeof(TestSession));
448 rc = sqlite3session_create(db, Tcl_GetString(objv[3]), &p->pSession);
449 if( rc!=SQLITE_OK ){
450 ckfree((char*)p);
451 return test_session_error(interp, rc, 0);
452 }
453
454 /* Query the SQLITE_SESSION_OBJCONFIG_SIZE option to ensure that it
455 ** is clear by default. Then set it. */
456 sqlite3session_object_config(p->pSession,SQLITE_SESSION_OBJCONFIG_SIZE,&iArg);
457 assert( iArg==0 );
458 iArg = 1;
459 sqlite3session_object_config(p->pSession,SQLITE_SESSION_OBJCONFIG_SIZE,&iArg);
460
461 Tcl_CreateObjCommand(
462 interp, Tcl_GetString(objv[1]), test_session_cmd, (ClientData)p,
463 test_session_del
464 );
465 Tcl_SetObjResult(interp, objv[1]);
466 return TCL_OK;
467 }
468
469 static void test_append_value(Tcl_Obj *pList, sqlite3_value *pVal){
470 if( pVal==0 ){
471 Tcl_ListObjAppendElement(0, pList, Tcl_NewObj());
472 Tcl_ListObjAppendElement(0, pList, Tcl_NewObj());
473 }else{
474 Tcl_Obj *pObj;
475 switch( sqlite3_value_type(pVal) ){
476 case SQLITE_NULL:
477 Tcl_ListObjAppendElement(0, pList, Tcl_NewStringObj("n", 1));
478 pObj = Tcl_NewObj();
479 break;
480 case SQLITE_INTEGER:
481 Tcl_ListObjAppendElement(0, pList, Tcl_NewStringObj("i", 1));
482 pObj = Tcl_NewWideIntObj(sqlite3_value_int64(pVal));
483 break;
484 case SQLITE_FLOAT:
485 Tcl_ListObjAppendElement(0, pList, Tcl_NewStringObj("f", 1));
486 pObj = Tcl_NewDoubleObj(sqlite3_value_double(pVal));
487 break;
488 case SQLITE_TEXT: {
489 const char *z = (char*)sqlite3_value_blob(pVal);
490 int n = sqlite3_value_bytes(pVal);
491 Tcl_ListObjAppendElement(0, pList, Tcl_NewStringObj("t", 1));
492 pObj = Tcl_NewStringObj(z, n);
493 break;
494 }
495 default:
496 assert( sqlite3_value_type(pVal)==SQLITE_BLOB );
497 Tcl_ListObjAppendElement(0, pList, Tcl_NewStringObj("b", 1));
498 pObj = Tcl_NewByteArrayObj(
499 sqlite3_value_blob(pVal),
500 sqlite3_value_bytes(pVal)
501 );
502 break;
503 }
504 Tcl_ListObjAppendElement(0, pList, pObj);
505 }
506 }
507
508 typedef struct TestConflictHandler TestConflictHandler;
509 struct TestConflictHandler {
510 Tcl_Interp *interp;
511 Tcl_Obj *pConflictScript;
512 Tcl_Obj *pFilterScript;
513 };
514
515 static int test_obj_eq_string(Tcl_Obj *p, const char *z){
516 Tcl_Size n;
517 Tcl_Size nObj;
518 char *zObj;
519
520 n = (Tcl_Size)strlen(z);
521 zObj = Tcl_GetStringFromObj(p, &nObj);
522
523 return (nObj==n && (n==0 || 0==memcmp(zObj, z, n)));
524 }
525
526 static Tcl_Obj *testIterData(sqlite3_changeset_iter *pIter){
527 Tcl_Obj *pVar = 0;
528 int nCol; /* Number of columns in table */
529 int nCol2; /* Number of columns in table */
530 int op; /* SQLITE_INSERT, UPDATE or DELETE */
531 const char *zTab; /* Name of table change applies to */
532 Tcl_Obj *pOld; /* Vector of old.* values */
533 Tcl_Obj *pNew; /* Vector of new.* values */
534 int bIndirect;
535
536 char *zPK;
537 unsigned char *abPK;
538 int i;
539
540 sqlite3changeset_op(pIter, &zTab, &nCol, &op, &bIndirect);
541 pVar = Tcl_NewObj();
542
543 Tcl_ListObjAppendElement(0, pVar, Tcl_NewStringObj(
544 op==SQLITE_INSERT ? "INSERT" :
545 op==SQLITE_UPDATE ? "UPDATE" :
546 "DELETE", -1
547 ));
548
549 Tcl_ListObjAppendElement(0, pVar, Tcl_NewStringObj(zTab, -1));
550 Tcl_ListObjAppendElement(0, pVar, Tcl_NewBooleanObj(bIndirect));
551
552 zPK = ckalloc(nCol+1);
553 memset(zPK, 0, nCol+1);
554 sqlite3changeset_pk(pIter, &abPK, &nCol2);
555 assert( nCol==nCol2 );
556 for(i=0; i<nCol; i++){
557 zPK[i] = (abPK[i] ? 'X' : '.');
558 }
559 Tcl_ListObjAppendElement(0, pVar, Tcl_NewStringObj(zPK, -1));
560 ckfree(zPK);
561
562 pOld = Tcl_NewObj();
563 if( op!=SQLITE_INSERT ){
564 for(i=0; i<nCol; i++){
565 sqlite3_value *pVal;
566 sqlite3changeset_old(pIter, i, &pVal);
567 test_append_value(pOld, pVal);
568 }
569 }
570 pNew = Tcl_NewObj();
571 if( op!=SQLITE_DELETE ){
572 for(i=0; i<nCol; i++){
573 sqlite3_value *pVal;
574 sqlite3changeset_new(pIter, i, &pVal);
575 test_append_value(pNew, pVal);
576 }
577 }
578 Tcl_ListObjAppendElement(0, pVar, pOld);
579 Tcl_ListObjAppendElement(0, pVar, pNew);
580
581 return pVar;
582 }
583
584
585 static int test_filter_handler(
586 void *pCtx, /* Pointer to TestConflictHandler structure */
587 const char *zTab /* Table name */
588 ){
589 TestConflictHandler *p = (TestConflictHandler *)pCtx;
590 int res = 1;
591 Tcl_Obj *pEval;
592 Tcl_Interp *interp = p->interp;
593
594 pEval = Tcl_DuplicateObj(p->pFilterScript);
595 Tcl_IncrRefCount(pEval);
596
597 if( TCL_OK!=Tcl_ListObjAppendElement(0, pEval, Tcl_NewStringObj(zTab, -1))
598 || TCL_OK!=Tcl_EvalObjEx(interp, pEval, TCL_EVAL_GLOBAL)
599 || TCL_OK!=Tcl_GetIntFromObj(interp, Tcl_GetObjResult(interp), &res)
600 ){
601 Tcl_BackgroundError(interp);
602 }
603
604 Tcl_DecrRefCount(pEval);
605 return res;
606 }
607
608 static int test_filter_v3_handler(
609 void *pCtx, /* Pointer to TestConflictHandler structure */
610 sqlite3_changeset_iter *pIter
611 ){
612 TestConflictHandler *p = (TestConflictHandler *)pCtx;
613 int res = 1;
614 Tcl_Obj *pEval = 0;
615 Tcl_Interp *interp = p->interp;
616
617 pEval = Tcl_DuplicateObj(p->pFilterScript);
618 Tcl_IncrRefCount(pEval);
619 Tcl_ListObjAppendElement(0, pEval, testIterData(pIter));
620
621 if( TCL_OK!=Tcl_EvalObjEx(interp, pEval, TCL_EVAL_GLOBAL)
622 || TCL_OK!=Tcl_GetIntFromObj(interp, Tcl_GetObjResult(interp), &res)
623 ){
624 Tcl_BackgroundError(interp);
625 }
626
627 Tcl_DecrRefCount(pEval);
628 return res;
629 }
630
631 static int test_conflict_handler(
632 void *pCtx, /* Pointer to TestConflictHandler structure */
633 int eConf, /* DATA, MISSING, CONFLICT, CONSTRAINT */
634 sqlite3_changeset_iter *pIter /* Handle describing change and conflict */
635 ){
636 TestConflictHandler *p = (TestConflictHandler *)pCtx;
637 Tcl_Obj *pEval;
638 Tcl_Interp *interp = p->interp;
639 int ret = 0; /* Return value */
640
641 int op; /* SQLITE_UPDATE, DELETE or INSERT */
642 const char *zTab; /* Name of table conflict is on */
643 int nCol; /* Number of columns in table zTab */
644
645 pEval = Tcl_DuplicateObj(p->pConflictScript);
646 Tcl_IncrRefCount(pEval);
647
648 sqlite3changeset_op(pIter, &zTab, &nCol, &op, 0);
649
650 if( eConf==SQLITE_CHANGESET_FOREIGN_KEY ){
651 int nFk;
652 sqlite3changeset_fk_conflicts(pIter, &nFk);
653 Tcl_ListObjAppendElement(0, pEval, Tcl_NewStringObj("FOREIGN_KEY", -1));
654 Tcl_ListObjAppendElement(0, pEval, Tcl_NewIntObj(nFk));
655 }else{
656
657 /* Append the operation type. */
658 Tcl_ListObjAppendElement(0, pEval, Tcl_NewStringObj(
659 op==SQLITE_INSERT ? "INSERT" :
660 op==SQLITE_UPDATE ? "UPDATE" :
661 "DELETE", -1
662 ));
663
664 /* Append the table name. */
665 Tcl_ListObjAppendElement(0, pEval, Tcl_NewStringObj(zTab, -1));
666
667 /* Append the conflict type. */
668 switch( eConf ){
669 case SQLITE_CHANGESET_DATA:
670 Tcl_ListObjAppendElement(interp, pEval,Tcl_NewStringObj("DATA",-1));
671 break;
672 case SQLITE_CHANGESET_NOTFOUND:
673 Tcl_ListObjAppendElement(interp, pEval,Tcl_NewStringObj("NOTFOUND",-1));
674 break;
675 case SQLITE_CHANGESET_CONFLICT:
676 Tcl_ListObjAppendElement(interp, pEval,Tcl_NewStringObj("CONFLICT",-1));
677 break;
678 case SQLITE_CHANGESET_CONSTRAINT:
679 Tcl_ListObjAppendElement(interp, pEval,Tcl_NewStringObj("CONSTRAINT",-1));
680 break;
681 }
682
683 /* If this is not an INSERT, append the old row */
684 if( op!=SQLITE_INSERT ){
685 int i;
686 Tcl_Obj *pOld = Tcl_NewObj();
687 for(i=0; i<nCol; i++){
688 sqlite3_value *pVal;
689 sqlite3changeset_old(pIter, i, &pVal);
690 test_append_value(pOld, pVal);
691 }
692 Tcl_ListObjAppendElement(0, pEval, pOld);
693 }
694
695 /* If this is not a DELETE, append the new row */
696 if( op!=SQLITE_DELETE ){
697 int i;
698 Tcl_Obj *pNew = Tcl_NewObj();
699 for(i=0; i<nCol; i++){
700 sqlite3_value *pVal;
701 sqlite3changeset_new(pIter, i, &pVal);
702 test_append_value(pNew, pVal);
703 }
704 Tcl_ListObjAppendElement(0, pEval, pNew);
705 }
706
707 /* If this is a CHANGESET_DATA or CHANGESET_CONFLICT conflict, append
708 ** the conflicting row. */
709 if( eConf==SQLITE_CHANGESET_DATA || eConf==SQLITE_CHANGESET_CONFLICT ){
710 int i;
711 Tcl_Obj *pConflict = Tcl_NewObj();
712 for(i=0; i<nCol; i++){
713 int rc;
714 sqlite3_value *pVal;
715 rc = sqlite3changeset_conflict(pIter, i, &pVal);
716 assert( rc==SQLITE_OK );
717 test_append_value(pConflict, pVal);
718 }
719 Tcl_ListObjAppendElement(0, pEval, pConflict);
720 }
721
722 /***********************************************************************
723 ** This block is purely for testing some error conditions.
724 */
725 if( eConf==SQLITE_CHANGESET_CONSTRAINT
726 || eConf==SQLITE_CHANGESET_NOTFOUND
727 ){
728 sqlite3_value *pVal;
729 int rc = sqlite3changeset_conflict(pIter, 0, &pVal);
730 assert( rc==SQLITE_MISUSE );
731 }else{
732 sqlite3_value *pVal;
733 int rc = sqlite3changeset_conflict(pIter, -1, &pVal);
734 assert( rc==SQLITE_RANGE );
735 rc = sqlite3changeset_conflict(pIter, nCol, &pVal);
736 assert( rc==SQLITE_RANGE );
737 }
738 if( op==SQLITE_DELETE ){
739 sqlite3_value *pVal;
740 int rc = sqlite3changeset_new(pIter, 0, &pVal);
741 assert( rc==SQLITE_MISUSE );
742 }else{
743 sqlite3_value *pVal;
744 int rc = sqlite3changeset_new(pIter, -1, &pVal);
745 assert( rc==SQLITE_RANGE );
746 rc = sqlite3changeset_new(pIter, nCol, &pVal);
747 assert( rc==SQLITE_RANGE );
748 }
749 if( op==SQLITE_INSERT ){
750 sqlite3_value *pVal;
751 int rc = sqlite3changeset_old(pIter, 0, &pVal);
752 assert( rc==SQLITE_MISUSE );
753 }else{
754 sqlite3_value *pVal;
755 int rc = sqlite3changeset_old(pIter, -1, &pVal);
756 assert( rc==SQLITE_RANGE );
757 rc = sqlite3changeset_old(pIter, nCol, &pVal);
758 assert( rc==SQLITE_RANGE );
759 }
760 if( eConf!=SQLITE_CHANGESET_FOREIGN_KEY ){
761 /* eConf!=FOREIGN_KEY is always true at this point. The condition is
762 ** just there to make it clearer what is being tested. */
763 int nDummy;
764 int rc = sqlite3changeset_fk_conflicts(pIter, &nDummy);
765 assert( rc==SQLITE_MISUSE );
766 }
767 /* End of testing block
768 ***********************************************************************/
769 }
770
771 if( TCL_OK!=Tcl_EvalObjEx(interp, pEval, TCL_EVAL_GLOBAL) ){
772 Tcl_BackgroundError(interp);
773 }else{
774 Tcl_Obj *pRes = Tcl_GetObjResult(interp);
775 if( test_obj_eq_string(pRes, "OMIT") || test_obj_eq_string(pRes, "") ){
776 ret = SQLITE_CHANGESET_OMIT;
777 }else if( test_obj_eq_string(pRes, "REPLACE") ){
778 ret = SQLITE_CHANGESET_REPLACE;
779 }else if( test_obj_eq_string(pRes, "ABORT") ){
780 ret = SQLITE_CHANGESET_ABORT;
781 }else{
782 Tcl_GetIntFromObj(0, pRes, &ret);
783 }
784 }
785
786 Tcl_DecrRefCount(pEval);
787 return ret;
788 }
789
790 /*
791 ** The conflict handler used by sqlite3changeset_apply_replace_all().
792 ** This conflict handler calls sqlite3_value_text16() on all available
793 ** sqlite3_value objects and then returns CHANGESET_REPLACE, or
794 ** CHANGESET_OMIT if REPLACE is not applicable. This is used to test the
795 ** effect of a malloc failure within an sqlite3_value_xxx() function
796 ** invoked by a conflict-handler callback.
797 */
798 static int replace_handler(
799 void *pCtx, /* Pointer to TestConflictHandler structure */
800 int eConf, /* DATA, MISSING, CONFLICT, CONSTRAINT */
801 sqlite3_changeset_iter *pIter /* Handle describing change and conflict */
802 ){
803 int op; /* SQLITE_UPDATE, DELETE or INSERT */
804 const char *zTab; /* Name of table conflict is on */
805 int nCol; /* Number of columns in table zTab */
806 int i;
807
808 sqlite3changeset_op(pIter, &zTab, &nCol, &op, 0);
809
810 if( op!=SQLITE_INSERT ){
811 for(i=0; i<nCol; i++){
812 sqlite3_value *pVal;
813 sqlite3changeset_old(pIter, i, &pVal);
814 sqlite3_value_text16(pVal);
815 }
816 }
817
818 if( op!=SQLITE_DELETE ){
819 for(i=0; i<nCol; i++){
820 sqlite3_value *pVal;
821 sqlite3changeset_new(pIter, i, &pVal);
822 sqlite3_value_text16(pVal);
823 }
824 }
825
826 if( eConf==SQLITE_CHANGESET_DATA ){
827 return SQLITE_CHANGESET_REPLACE;
828 }
829 return SQLITE_CHANGESET_OMIT;
830 }
831
832 static int testStreamInput(
833 void *pCtx, /* Context pointer */
834 void *pData, /* Buffer to populate */
835 int *pnData /* IN/OUT: Bytes requested/supplied */
836 ){
837 TestStreamInput *p = (TestStreamInput*)pCtx;
838 int nReq = *pnData; /* Bytes of data requested */
839 int nRem = p->nData - p->iData; /* Bytes of data available */
840 int nRet = p->nStream; /* Bytes actually returned */
841
842 /* Allocate and free some space. There is no point to this, other than
843 ** that it allows the regular OOM fault-injection tests to cause an error
844 ** in this function. */
845 void *pAlloc = sqlite3_malloc(10);
846 if( pAlloc==0 ) return SQLITE_NOMEM;
847 sqlite3_free(pAlloc);
848
849 if( nRet>nReq ) nRet = nReq;
850 if( nRet>nRem ) nRet = nRem;
851
852 assert( nRet>=0 );
853 if( nRet>0 ){
854 memcpy(pData, &p->aData[p->iData], nRet);
855 p->iData += nRet;
856 }
857
858 *pnData = nRet;
859 return SQLITE_OK;
860 }
861
862 /*
863 ** This works like Tcl_GetByteArrayFromObj(), except that it returns a buffer
864 ** allocated using malloc() that must be freed by the caller. This is done
865 ** because Tcl's buffers are often padded by a few bytes, which prevents
866 ** small overreads from being detected when tests are run under asan.
867 */
868 static void *testGetByteArrayFromObj(Tcl_Obj *p, Tcl_Size *pnByte){
869 Tcl_Size nByte = 0;
870 void *aByte = Tcl_GetByteArrayFromObj(p, &nByte);
871 void *aCopy = malloc(nByte ? (size_t)nByte : 1);
872 memcpy(aCopy, aByte, (size_t)nByte);
873 *pnByte = nByte;
874 return aCopy;
875 }
876
877
878 static int SQLITE_TCLAPI testSqlite3changesetApply(
879 int iVersion,
880 void * clientData,
881 Tcl_Interp *interp,
882 int objc,
883 Tcl_Obj *CONST objv[]
884 ){
885 sqlite3 *db; /* Database handle */
886 Tcl_CmdInfo info; /* Database Tcl command (objv[1]) info */
887 int rc; /* Return code from changeset_invert() */
888 void *pChangeset; /* Buffer containing changeset */
889 Tcl_Size nChangeset; /* Size of buffer aChangeset in bytes */
890 TestConflictHandler ctx;
891 TestStreamInput sStr;
892 void *pRebase = 0;
893 int nRebase = 0;
894 int flags = 0; /* Flags for apply_v2() */
895
896 assert( iVersion==1 || iVersion==2 || iVersion==3 );
897
898 memset(&sStr, 0, sizeof(sStr));
899 sStr.nStream = test_tcl_integer(interp, SESSION_STREAM_TCL_VAR);
900
901 /* Check for the -nosavepoint, -invert or -ignorenoop switches */
902 if( iVersion==2 || iVersion==3 ){
903 while( objc>1 ){
904 const char *z1 = Tcl_GetString(objv[1]);
905 int n = (int)strlen(z1);
906 if( n>3 && n<=12 && 0==sqlite3_strnicmp("-nosavepoint", z1, n) ){
907 flags |= SQLITE_CHANGESETAPPLY_NOSAVEPOINT;
908 }
909 else if( n>3 && n<=9 && 0==sqlite3_strnicmp("-noaction", z1, n) ){
910 flags |= SQLITE_CHANGESETAPPLY_FKNOACTION;
911 }
912 else if( n>2 && n<=7 && 0==sqlite3_strnicmp("-invert", z1, n) ){
913 flags |= SQLITE_CHANGESETAPPLY_INVERT;
914 }
915 else if( n>2 && n<=11 && 0==sqlite3_strnicmp("-ignorenoop", z1, n) ){
916 flags |= SQLITE_CHANGESETAPPLY_IGNORENOOP;
917 }
918 else if( n>3 && n<=13 && 0==sqlite3_strnicmp("-noupdateloop", z1, n) ){
919 flags |= SQLITE_CHANGESETAPPLY_NOUPDATELOOP;
920 }else{
921 break;
922 }
923 objc--;
924 objv++;
925 }
926 }
927
928 if( objc!=4 && objc!=5 ){
929 const char *zMsg;
930 if( iVersion==2 || iVersion==3 ){
931 zMsg = "?-nosavepoint? ?-inverse? ?-ignorenoop? "
932 "DB CHANGESET CONFLICT-SCRIPT ?FILTER-SCRIPT?";
933 }else{
934 zMsg = "DB CHANGESET CONFLICT-SCRIPT ?FILTER-SCRIPT?";
935 }
936 Tcl_WrongNumArgs(interp, 1, objv, zMsg);
937 return TCL_ERROR;
938 }
939 if( 0==Tcl_GetCommandInfo(interp, Tcl_GetString(objv[1]), &info) ){
940 Tcl_AppendResult(interp, "no such handle: ", Tcl_GetString(objv[1]), NULL);
941 return TCL_ERROR;
942 }
943 db = *(sqlite3 **)info.objClientData;
944 pChangeset = (void *)testGetByteArrayFromObj(objv[2], &nChangeset);
945 ctx.pConflictScript = objv[3];
946 ctx.pFilterScript = objc==5 ? objv[4] : 0;
947 ctx.interp = interp;
948
949 if( sStr.nStream==0 ){
950 switch( iVersion ){
951 case 1:
952 rc = sqlite3changeset_apply(db, (int)nChangeset, pChangeset,
953 (objc==5)?test_filter_handler:0, test_conflict_handler, (void*)&ctx
954 );
955 break;
956 case 2:
957 rc = sqlite3changeset_apply_v2(db, (int)nChangeset, pChangeset,
958 (objc==5)?test_filter_handler:0, test_conflict_handler, (void*)&ctx,
959 &pRebase, &nRebase, flags
960 );
961 break;
962 case 3:
963 rc = sqlite3changeset_apply_v3(db, (int)nChangeset, pChangeset,
964 (objc==5)?test_filter_v3_handler:0, test_conflict_handler,
965 (void*)&ctx, &pRebase, &nRebase, flags
966 );
967 break;
968 }
969 }else{
970 sStr.aData = (unsigned char*)pChangeset;
971 sStr.nData = (int)nChangeset;
972 switch( iVersion ){
973 case 1:
974 rc = sqlite3changeset_apply_strm(db, testStreamInput, (void*)&sStr,
975 (objc==5) ? test_filter_handler : 0,
976 test_conflict_handler, (void *)&ctx
977 );
978 break;
979 case 2:
980 rc = sqlite3changeset_apply_v2_strm(db, testStreamInput, (void*)&sStr,
981 (objc==5) ? test_filter_handler : 0,
982 test_conflict_handler, (void *)&ctx,
983 &pRebase, &nRebase, flags
984 );
985 break;
986 case 3:
987 rc = sqlite3changeset_apply_v3_strm(db, testStreamInput, (void*)&sStr,
988 (objc==5) ? test_filter_v3_handler : 0,
989 test_conflict_handler, (void *)&ctx,
990 &pRebase, &nRebase, flags
991 );
992 break;
993 }
994 }
995
996 free(pChangeset);
997 if( rc!=SQLITE_OK ){
998 return test_session_error(interp, rc, 0);
999 }else{
1000 Tcl_ResetResult(interp);
1001 if( (iVersion==2 || iVersion==3) && pRebase ){
1002 Tcl_SetObjResult(interp, Tcl_NewByteArrayObj(pRebase, nRebase));
1003 }
1004 }
1005 sqlite3_free(pRebase);
1006 return TCL_OK;
1007 }
1008
1009 /*
1010 ** sqlite3changeset_apply DB CHANGESET CONFLICT-SCRIPT ?FILTER-SCRIPT?
1011 */
1012 static int SQLITE_TCLAPI test_sqlite3changeset_apply(
1013 void * clientData,
1014 Tcl_Interp *interp,
1015 int objc,
1016 Tcl_Obj *CONST objv[]
1017 ){
1018 return testSqlite3changesetApply(1, clientData, interp, objc, objv);
1019 }
1020 /*
1021 ** sqlite3changeset_apply_v2 DB CHANGESET CONFLICT-SCRIPT ?FILTER-SCRIPT?
1022 */
1023 static int SQLITE_TCLAPI test_sqlite3changeset_apply_v2(
1024 void * clientData,
1025 Tcl_Interp *interp,
1026 int objc,
1027 Tcl_Obj *CONST objv[]
1028 ){
1029 return testSqlite3changesetApply(2, clientData, interp, objc, objv);
1030 }
1031 /*
1032 ** sqlite3changeset_apply_v3 DB CHANGESET CONFLICT-SCRIPT ?FILTER-SCRIPT?
1033 */
1034 static int SQLITE_TCLAPI test_sqlite3changeset_apply_v3(
1035 void * clientData,
1036 Tcl_Interp *interp,
1037 int objc,
1038 Tcl_Obj *CONST objv[]
1039 ){
1040 return testSqlite3changesetApply(3, clientData, interp, objc, objv);
1041 }
1042
1043 /*
1044 ** sqlite3changeset_apply_replace_all DB CHANGESET
1045 */
1046 static int SQLITE_TCLAPI test_sqlite3changeset_apply_replace_all(
1047 void * clientData,
1048 Tcl_Interp *interp,
1049 int objc,
1050 Tcl_Obj *CONST objv[]
1051 ){
1052 sqlite3 *db; /* Database handle */
1053 Tcl_CmdInfo info; /* Database Tcl command (objv[1]) info */
1054 int rc; /* Return code from changeset_invert() */
1055 void *pChangeset; /* Buffer containing changeset */
1056 Tcl_Size nChangeset; /* Size of buffer aChangeset in bytes */
1057
1058 if( objc!=3 ){
1059 Tcl_WrongNumArgs(interp, 1, objv, "DB CHANGESET");
1060 return TCL_ERROR;
1061 }
1062 if( 0==Tcl_GetCommandInfo(interp, Tcl_GetString(objv[1]), &info) ){
1063 Tcl_AppendResult(interp, "no such handle: ", Tcl_GetString(objv[2]), NULL);
1064 return TCL_ERROR;
1065 }
1066 db = *(sqlite3 **)info.objClientData;
1067 pChangeset = (void *)Tcl_GetByteArrayFromObj(objv[2], &nChangeset);
1068
1069 rc = sqlite3changeset_apply(db, (int)nChangeset, pChangeset,
1070 0, replace_handler,0);
1071 if( rc!=SQLITE_OK ){
1072 return test_session_error(interp, rc, 0);
1073 }
1074 Tcl_ResetResult(interp);
1075 return TCL_OK;
1076 }
1077
1078
1079 /*
1080 ** sqlite3changeset_invert CHANGESET
1081 */
1082 static int SQLITE_TCLAPI test_sqlite3changeset_invert(
1083 void * clientData,
1084 Tcl_Interp *interp,
1085 int objc,
1086 Tcl_Obj *CONST objv[]
1087 ){
1088 int rc; /* Return code from changeset_invert() */
1089 Tcl_Size nn;
1090 TestStreamInput sIn; /* Input stream */
1091 TestSessionsBlob sOut; /* Output blob */
1092
1093 if( objc!=2 ){
1094 Tcl_WrongNumArgs(interp, 1, objv, "CHANGESET");
1095 return TCL_ERROR;
1096 }
1097
1098 memset(&sIn, 0, sizeof(sIn));
1099 memset(&sOut, 0, sizeof(sOut));
1100 sIn.nStream = test_tcl_integer(interp, SESSION_STREAM_TCL_VAR);
1101 sIn.aData = testGetByteArrayFromObj(objv[1], &nn);
1102 sIn.nData = (int)nn;
1103
1104 if( sIn.nStream ){
1105 rc = sqlite3changeset_invert_strm(
1106 testStreamInput, (void*)&sIn, testStreamOutput, (void*)&sOut
1107 );
1108 }else{
1109 rc = sqlite3changeset_invert(sIn.nData, sIn.aData, &sOut.n, &sOut.p);
1110 }
1111 if( rc!=SQLITE_OK ){
1112 rc = test_session_error(interp, rc, 0);
1113 }else{
1114 assert_changeset_is_ok(sOut.n, sOut.p);
1115 Tcl_SetObjResult(interp,Tcl_NewByteArrayObj((unsigned char*)sOut.p,sOut.n));
1116 }
1117 sqlite3_free(sOut.p);
1118 free(sIn.aData);
1119 return rc;
1120 }
1121
1122 /*
1123 ** Copy buffer aIn[] to a new nIn byte buffer obtained from malloc(). Use
1124 ** plain malloc() instead of any Tcl function because valgrind and asan are
1125 ** better at detecting small overflows in that case. Avoid sqlite3_malloc()
1126 ** here because that means dealing with injected OOM errors.
1127 **
1128 ** The caller is responsible for eventually calling free() on the returned
1129 ** value.
1130 */
1131 static u8 *copyToMalloc(const u8 *aIn, int nIn){
1132 u8 *pRet = malloc(nIn);
1133 memcpy(pRet, aIn, nIn);
1134 return pRet;
1135 }
1136
1137 /*
1138 ** sqlite3changeset_concat LEFT RIGHT
1139 */
1140 static int SQLITE_TCLAPI test_sqlite3changeset_concat(
1141 void * clientData,
1142 Tcl_Interp *interp,
1143 int objc,
1144 Tcl_Obj *CONST objv[]
1145 ){
1146 int rc; /* Return code from changeset_invert() */
1147 Tcl_Size nn;
1148
1149 TestStreamInput sLeft; /* Input stream */
1150 TestStreamInput sRight; /* Input stream */
1151 TestSessionsBlob sOut = {0,0}; /* Output blob */
1152
1153 if( objc!=3 ){
1154 Tcl_WrongNumArgs(interp, 1, objv, "LEFT RIGHT");
1155 return TCL_ERROR;
1156 }
1157
1158 memset(&sLeft, 0, sizeof(sLeft));
1159 memset(&sRight, 0, sizeof(sRight));
1160 sLeft.aData = Tcl_GetByteArrayFromObj(objv[1], &nn);
1161 sLeft.nData = (int)nn;
1162 sRight.aData = Tcl_GetByteArrayFromObj(objv[2], &nn);
1163 sRight.nData = (int)nn;
1164 sLeft.nStream = test_tcl_integer(interp, SESSION_STREAM_TCL_VAR);
1165 sRight.nStream = sLeft.nStream;
1166
1167 sLeft.aData = copyToMalloc(sLeft.aData, sLeft.nData);
1168 sRight.aData = copyToMalloc(sRight.aData, sRight.nData);
1169
1170 if( sLeft.nStream>0 ){
1171 rc = sqlite3changeset_concat_strm(
1172 testStreamInput, (void*)&sLeft,
1173 testStreamInput, (void*)&sRight,
1174 testStreamOutput, (void*)&sOut
1175 );
1176 }else{
1177 rc = sqlite3changeset_concat(
1178 sLeft.nData, sLeft.aData, sRight.nData, sRight.aData, &sOut.n, &sOut.p
1179 );
1180 }
1181
1182 free(sLeft.aData);
1183 free(sRight.aData);
1184
1185 if( rc!=SQLITE_OK ){
1186 rc = test_session_error(interp, rc, 0);
1187 }else{
1188 assert_changeset_is_ok(sOut.n, sOut.p);
1189 Tcl_SetObjResult(interp,Tcl_NewByteArrayObj((unsigned char*)sOut.p,sOut.n));
1190 }
1191 sqlite3_free(sOut.p);
1192 return rc;
1193 }
1194
1195 /*
1196 ** sqlite3session_foreach VARNAME CHANGESET SCRIPT
1197 */
1198 static int SQLITE_TCLAPI test_sqlite3session_foreach(
1199 void * clientData,
1200 Tcl_Interp *interp,
1201 int objc,
1202 Tcl_Obj *CONST objv[]
1203 ){
1204 void *pChangeset;
1205 Tcl_Size nChangeset;
1206 sqlite3_changeset_iter *pIter;
1207 int rc;
1208 Tcl_Obj *pVarname;
1209 Tcl_Obj *pCS;
1210 Tcl_Obj *pScript;
1211 int isCheckNext = 0;
1212 int isInvert = 0;
1213
1214 TestStreamInput sStr;
1215 memset(&sStr, 0, sizeof(sStr));
1216
1217 while( objc>1 ){
1218 char *zOpt = Tcl_GetString(objv[1]);
1219 int nOpt = (int)strlen(zOpt);
1220 if( zOpt[0]!='-' ) break;
1221 if( nOpt<=7 && 0==sqlite3_strnicmp(zOpt, "-invert", nOpt) ){
1222 isInvert = 1;
1223 }else
1224 if( nOpt<=5 && 0==sqlite3_strnicmp(zOpt, "-next", nOpt) ){
1225 isCheckNext = 1;
1226 }else{
1227 break;
1228 }
1229 objv++;
1230 objc--;
1231 }
1232 if( objc!=4 ){
1233 Tcl_WrongNumArgs(
1234 interp, 1, objv, "?-next? ?-invert? VARNAME CHANGESET SCRIPT");
1235 return TCL_ERROR;
1236 }
1237
1238 pVarname = objv[1];
1239 pCS = objv[2];
1240 pScript = objv[3];
1241
1242 /* Take a copy of the changeset into an exact sized buffer allocated
1243 ** using malloc(). The Tcl buffer will be padded by a few bytes, which
1244 ** prevents small overreads from being detected by ASAN when the tests
1245 ** are run. */
1246 pChangeset = (void*)testGetByteArrayFromObj(pCS, &nChangeset);
1247
1248 sStr.nStream = test_tcl_integer(interp, SESSION_STREAM_TCL_VAR);
1249 if( isInvert ){
1250 int f = SQLITE_CHANGESETSTART_INVERT;
1251 if( sStr.nStream==0 ){
1252 rc = sqlite3changeset_start_v2(&pIter, (int)nChangeset, pChangeset, f);
1253 }else{
1254 void *pCtx = (void*)&sStr;
1255 sStr.aData = (unsigned char*)pChangeset;
1256 sStr.nData = (int)nChangeset;
1257 rc = sqlite3changeset_start_v2_strm(&pIter, testStreamInput, pCtx, f);
1258 }
1259 }else{
1260 if( sStr.nStream==0 ){
1261 rc = sqlite3changeset_start(&pIter, (int)nChangeset, pChangeset);
1262 }else{
1263 sStr.aData = (unsigned char*)pChangeset;
1264 sStr.nData = (int)nChangeset;
1265 rc = sqlite3changeset_start_strm(&pIter, testStreamInput, (void*)&sStr);
1266 }
1267 }
1268
1269 if( rc==SQLITE_OK ){
1270 while( SQLITE_ROW==sqlite3changeset_next(pIter) ){
1271 Tcl_Obj *pVar = 0; /* Tcl value to set $VARNAME to */
1272 pVar = testIterData(pIter);
1273 Tcl_ObjSetVar2(interp, pVarname, 0, pVar, 0);
1274 rc = Tcl_EvalObjEx(interp, pScript, 0);
1275 if( rc!=TCL_OK && rc!=TCL_CONTINUE ){
1276 sqlite3changeset_finalize(pIter);
1277 free(pChangeset);
1278 return rc==TCL_BREAK ? TCL_OK : rc;
1279 }
1280 }
1281
1282 if( isCheckNext ){
1283 int rc2 = sqlite3changeset_next(pIter);
1284 rc = sqlite3changeset_finalize(pIter);
1285 assert( (rc2==SQLITE_DONE && rc==SQLITE_OK) || rc2==rc );
1286 }else{
1287 rc = sqlite3changeset_finalize(pIter);
1288 }
1289 }
1290
1291 free(pChangeset);
1292 if( rc!=SQLITE_OK ){
1293 return test_session_error(interp, rc, 0);
1294 }
1295 return TCL_OK;
1296 }
1297
1298 /*
1299 ** tclcmd: CMD configure REBASE-BLOB
1300 ** tclcmd: CMD rebase CHANGESET
1301 ** tclcmd: CMD delete
1302 */
1303 static int SQLITE_TCLAPI test_rebaser_cmd(
1304 void * clientData,
1305 Tcl_Interp *interp,
1306 int objc,
1307 Tcl_Obj *CONST objv[]
1308 ){
1309 static struct RebaseSubcmd {
1310 const char *zSub;
1311 int nArg;
1312 const char *zMsg;
1313 int iSub;
1314 } aSub[] = {
1315 { "configure", 1, "REBASE-BLOB" }, /* 0 */
1316 { "delete", 0, "" }, /* 1 */
1317 { "rebase", 1, "CHANGESET" }, /* 2 */
1318 { 0 }
1319 };
1320
1321 sqlite3_rebaser *p = (sqlite3_rebaser*)clientData;
1322 int iSub;
1323 int rc;
1324
1325 if( objc<2 ){
1326 Tcl_WrongNumArgs(interp, 1, objv, "SUBCOMMAND ...");
1327 return TCL_ERROR;
1328 }
1329 rc = Tcl_GetIndexFromObjStruct(interp,
1330 objv[1], aSub, sizeof(aSub[0]), "sub-command", 0, &iSub
1331 );
1332 if( rc!=TCL_OK ) return rc;
1333 if( objc!=2+aSub[iSub].nArg ){
1334 Tcl_WrongNumArgs(interp, 2, objv, aSub[iSub].zMsg);
1335 return TCL_ERROR;
1336 }
1337
1338 assert( iSub==0 || iSub==1 || iSub==2 );
1339 assert( rc==SQLITE_OK );
1340 switch( iSub ){
1341 case 0: { /* configure */
1342 Tcl_Size nRebase = 0;
1343 unsigned char *pRebase = Tcl_GetByteArrayFromObj(objv[2], &nRebase);
1344 rc = sqlite3rebaser_configure(p, (int)nRebase, pRebase);
1345 break;
1346 }
1347
1348 case 1: /* delete */
1349 Tcl_DeleteCommand(interp, Tcl_GetString(objv[0]));
1350 break;
1351
1352 default: { /* rebase */
1353 TestStreamInput sStr; /* Input stream */
1354 TestSessionsBlob sOut; /* Output blob */
1355 Tcl_Size nn;
1356
1357 memset(&sStr, 0, sizeof(sStr));
1358 memset(&sOut, 0, sizeof(sOut));
1359 sStr.aData = Tcl_GetByteArrayFromObj(objv[2], &nn);
1360 sStr.nData = nn;
1361 sStr.nStream = test_tcl_integer(interp, SESSION_STREAM_TCL_VAR);
1362
1363 if( sStr.nStream ){
1364 rc = sqlite3rebaser_rebase_strm(p,
1365 testStreamInput, (void*)&sStr,
1366 testStreamOutput, (void*)&sOut
1367 );
1368 }else{
1369 rc = sqlite3rebaser_rebase(p, sStr.nData, sStr.aData, &sOut.n, &sOut.p);
1370 }
1371
1372 if( rc==SQLITE_OK ){
1373 assert_changeset_is_ok(sOut.n, sOut.p);
1374 Tcl_SetObjResult(interp, Tcl_NewByteArrayObj(sOut.p, sOut.n));
1375 }
1376 sqlite3_free(sOut.p);
1377 break;
1378 }
1379 }
1380
1381 if( rc!=SQLITE_OK ){
1382 return test_session_error(interp, rc, 0);
1383 }
1384 return TCL_OK;
1385 }
1386
1387 static void SQLITE_TCLAPI test_rebaser_del(void *clientData){
1388 sqlite3_rebaser *p = (sqlite3_rebaser*)clientData;
1389 sqlite3rebaser_delete(p);
1390 }
1391
1392 /*
1393 ** tclcmd: sqlite3rebaser_create NAME
1394 */
1395 static int SQLITE_TCLAPI test_sqlite3rebaser_create(
1396 void * clientData,
1397 Tcl_Interp *interp,
1398 int objc,
1399 Tcl_Obj *CONST objv[]
1400 ){
1401 int rc;
1402 sqlite3_rebaser *pNew = 0;
1403 if( objc!=2 ){
1404 Tcl_WrongNumArgs(interp, 1, objv, "NAME");
1405 return SQLITE_ERROR;
1406 }
1407
1408 rc = sqlite3rebaser_create(&pNew);
1409 if( rc!=SQLITE_OK ){
1410 return test_session_error(interp, rc, 0);
1411 }
1412
1413 Tcl_CreateObjCommand(interp, Tcl_GetString(objv[1]), test_rebaser_cmd,
1414 (ClientData)pNew, test_rebaser_del
1415 );
1416 Tcl_SetObjResult(interp, objv[1]);
1417 return TCL_OK;
1418 }
1419
1420 /*
1421 ** Run some sanity checks on the changeset in nChangeset byte buffer
1422 ** pChangeset. If any fail, return a non-zero value and, optionally,
1423 ** set output variable (*pzErr) to point to a buffer containing an
1424 ** English language error message describing the problem. In this
1425 ** case it is the responsibility of the caller to free the buffer
1426 ** using sqlite3_free().
1427 **
1428 ** Or, if the changeset appears to be well-formed, this function
1429 ** returns SQLITE_OK and sets (*pzErr) to NULL.
1430 */
1431 static int sqlite3_test_changeset(
1432 int nChangeset,
1433 void *pChangeset,
1434 char **pzErr
1435 ){
1436 sqlite3_changeset_iter *pIter = 0;
1437 char *zErr = 0;
1438 int rc = SQLITE_OK;
1439 int bPatch = (nChangeset>0 && ((char*)pChangeset)[0]=='P');
1440
1441 rc = sqlite3changeset_start(&pIter, nChangeset, pChangeset);
1442 if( rc==SQLITE_OK ){
1443 int rc2;
1444 while( rc==SQLITE_OK && SQLITE_ROW==sqlite3changeset_next(pIter) ){
1445 unsigned char *aPk = 0;
1446 int nCol = 0;
1447 int op = 0;
1448 const char *zTab = 0;
1449
1450 sqlite3changeset_pk(pIter, &aPk, &nCol);
1451 sqlite3changeset_op(pIter, &zTab, &nCol, &op, 0);
1452
1453 if( op==SQLITE_UPDATE ){
1454 int iCol;
1455 for(iCol=0; iCol<nCol; iCol++){
1456 sqlite3_value *pNew = 0;
1457 sqlite3_value *pOld = 0;
1458 sqlite3changeset_new(pIter, iCol, &pNew);
1459 sqlite3changeset_old(pIter, iCol, &pOld);
1460
1461 if( aPk[iCol] ){
1462 if( pOld==0 ) rc = SQLITE_ERROR;
1463 }else if( bPatch ){
1464 if( pOld ) rc = SQLITE_ERROR;
1465 }else{
1466 if( (pOld==0)!=(pNew==0) ) rc = SQLITE_ERROR;
1467 }
1468
1469 if( rc!=SQLITE_OK ){
1470 zErr = sqlite3_mprintf(
1471 "unexpected SQLITE_UPDATE (bPatch=%d pk=%d pOld=%d pNew=%d)",
1472 bPatch, (int)aPk[iCol], pOld!=0, pNew!=0
1473 );
1474 break;
1475 }
1476 }
1477 }
1478 }
1479 rc2 = sqlite3changeset_finalize(pIter);
1480 if( rc==SQLITE_OK ){
1481 rc = rc2;
1482 }
1483 }
1484
1485 *pzErr = zErr;
1486 return rc;
1487 }
1488
1489 /*
1490 ** test_changeset CHANGESET
1491 */
1492 static int SQLITE_TCLAPI test_changeset(
1493 void * clientData,
1494 Tcl_Interp *interp,
1495 int objc,
1496 Tcl_Obj *CONST objv[]
1497 ){
1498 void *pChangeset = 0; /* Buffer containing changeset */
1499 Tcl_Size nChangeset = 0; /* Size of buffer aChangeset in bytes */
1500 int rc = SQLITE_OK;
1501 char *z = 0;
1502
1503 if( objc!=2 ){
1504 Tcl_WrongNumArgs(interp, 1, objv, "CHANGESET");
1505 return TCL_ERROR;
1506 }
1507 pChangeset = (void *)Tcl_GetByteArrayFromObj(objv[1], &nChangeset);
1508
1509 Tcl_ResetResult(interp);
1510 rc = sqlite3_test_changeset((int)nChangeset, pChangeset, &z);
1511 if( rc!=SQLITE_OK ){
1512 char *zErr = sqlite3_mprintf("(%d) - \"%s\"", rc, z);
1513 Tcl_SetObjResult(interp, Tcl_NewStringObj(zErr, -1));
1514 sqlite3_free(zErr);
1515 }
1516 sqlite3_free(z);
1517
1518 return rc ? TCL_ERROR : TCL_OK;
1519 }
1520
1521 /*
1522 ** tclcmd: sqlite3rebaser_configure OP VALUE
1523 */
1524 static int SQLITE_TCLAPI test_sqlite3session_config(
1525 void * clientData,
1526 Tcl_Interp *interp,
1527 int objc,
1528 Tcl_Obj *CONST objv[]
1529 ){
1530 static struct ConfigOpt {
1531 const char *zSub;
1532 int op;
1533 } aSub[] = {
1534 { "strm_size", SQLITE_SESSION_CONFIG_STRMSIZE },
1535 { "invalid", 0 },
1536 { 0 }
1537 };
1538 int rc;
1539 int iSub;
1540 int iVal;
1541
1542 if( objc!=3 ){
1543 Tcl_WrongNumArgs(interp, 1, objv, "OP VALUE");
1544 return SQLITE_ERROR;
1545 }
1546 rc = Tcl_GetIndexFromObjStruct(interp,
1547 objv[1], aSub, sizeof(aSub[0]), "sub-command", 0, &iSub
1548 );
1549 if( rc!=TCL_OK ) return rc;
1550 if( Tcl_GetIntFromObj(interp, objv[2], &iVal) ) return TCL_ERROR;
1551
1552 rc = sqlite3session_config(aSub[iSub].op, (void*)&iVal);
1553 if( rc!=SQLITE_OK ){
1554 return test_session_error(interp, rc, 0);
1555 }
1556 Tcl_SetObjResult(interp, Tcl_NewIntObj(iVal));
1557 return TCL_OK;
1558 }
1559
1560 typedef struct TestChangegroup TestChangegroup;
1561 struct TestChangegroup {
1562 sqlite3_changegroup *pGrp;
1563 };
1564
1565 typedef struct TestChangeIter TestChangeIter;
1566 struct TestChangeIter {
1567 sqlite3_changeset_iter *pIter;
1568
1569 /* If this iter uses streaming. */
1570 TestStreamInput in;
1571 };
1572
1573
1574 /*
1575 ** Destructor for Tcl changegroup command object.
1576 */
1577 static void test_changegroup_del(void *clientData){
1578 TestChangegroup *pGrp = (TestChangegroup*)clientData;
1579 sqlite3changegroup_delete(pGrp->pGrp);
1580 ckfree(pGrp);
1581 }
1582
1583 static int testGetNewOrOld(Tcl_Interp *interp, Tcl_Obj *pObj, int *pbNew){
1584 const char *azVal[] = { "old", "new", 0 };
1585 int iIdx = 0;
1586 int rc = Tcl_GetIndexFromObj(interp, pObj, azVal, "record", 0, &iIdx);
1587 *pbNew = iIdx;
1588 return rc;
1589 }
1590
1591 /*
1592 ** Tclcmd: $changegroup schema DB DBNAME
1593 ** Tclcmd: $changegroup add CHANGESET
1594 ** Tclcmd: $changegroup output
1595 ** Tclcmd: $changegroup delete
1596 */
1597 static int SQLITE_TCLAPI test_changegroup_cmd(
1598 void * clientData,
1599 Tcl_Interp *interp,
1600 int objc,
1601 Tcl_Obj *CONST objv[]
1602 ){
1603 TestChangegroup *p = (TestChangegroup*)clientData;
1604 static struct ChangegroupCmd {
1605 const char *zSub;
1606 int nArg;
1607 const char *zMsg;
1608 } aSub[] = {
1609 { "schema", 2, "DB DBNAME" }, /* 0 */
1610 { "add", 1, "CHANGESET" }, /* 1 */
1611 { "output", 0, "" }, /* 2 */
1612 { "delete", 0, "" }, /* 3 */
1613 { "add_change", 1, "ITERATOR" }, /* 4 */
1614
1615 { "change_begin", 3, "TYPE TABLE INDIRECT" }, /* 5 */
1616 { "change_int64", 3, "[new|old] ICOL VALUE" }, /* 6 */
1617 { "change_null", 2, "[new|old] ICOL" }, /* 7 */
1618 { "change_double", 3, "[new|old] ICOL VALUE" }, /* 8 */
1619 { "change_text", 3, "[new|old] ICOL VALUE" }, /* 9 */
1620 { "change_blob", 3, "[new|old] ICOL VALUE" }, /* 10 */
1621 { "change_finish", 1, "BDISCARD" }, /* 11 */
1622
1623 { "config", 2, "OPTION INTVAL" }, /* 12 */
1624 { "change_text-1", 3, "[new|old] ICOL VALUE" }, /* 13 */
1625 { "change_begin_ne", 3, "TYPE TABLE INDIRECT" }, /* 14 */
1626 { 0, 0, 0 }
1627 };
1628 int rc = TCL_OK;
1629 int iSub = 0;
1630
1631 if( objc<2 ){
1632 Tcl_WrongNumArgs(interp, 1, objv, "SUBCOMMAND ...");
1633 return TCL_ERROR;
1634 }
1635 rc = Tcl_GetIndexFromObjStruct(interp,
1636 objv[1], aSub, sizeof(aSub[0]), "sub-command", 0, &iSub
1637 );
1638 if( rc!=TCL_OK ) return rc;
1639 if( objc!=2+aSub[iSub].nArg ){
1640 Tcl_WrongNumArgs(interp, 2, objv, aSub[iSub].zMsg);
1641 return TCL_ERROR;
1642 }
1643
1644 switch( iSub ){
1645 case 0: { /* schema */
1646 sqlite3 *db = 0;
1647 const char *zDb = Tcl_GetString(objv[3]);
1648 if( dbHandleFromObj(interp, objv[2], &db) ){
1649 return TCL_ERROR;
1650 }
1651 rc = sqlite3changegroup_schema(p->pGrp, db, zDb);
1652 if( rc!=SQLITE_OK ) rc = test_session_error(interp, rc, 0);
1653 break;
1654 };
1655
1656 case 1: { /* add */
1657 Tcl_Size nByte = 0;
1658 const u8 *aByte = Tcl_GetByteArrayFromObj(objv[2], &nByte);
1659 rc = sqlite3changegroup_add(p->pGrp, (int)nByte, (void*)aByte);
1660 if( rc!=SQLITE_OK ) rc = test_session_error(interp, rc, 0);
1661 break;
1662 };
1663
1664 case 2: { /* output */
1665 int nByte = 0;
1666 u8 *aByte = 0;
1667 rc = sqlite3changegroup_output(p->pGrp, &nByte, (void**)&aByte);
1668 if( rc!=SQLITE_OK ){
1669 rc = test_session_error(interp, rc, 0);
1670 }else{
1671 Tcl_SetObjResult(interp, Tcl_NewByteArrayObj(aByte, nByte));
1672 }
1673 sqlite3_free(aByte);
1674 break;
1675 };
1676
1677 case 4: { /* add_change */
1678 Tcl_CmdInfo cmdInfo; /* Database Tcl command (objv[2]) info */
1679 TestChangeIter *pIter = 0;
1680 const char *zIter = Tcl_GetString(objv[2]);
1681 if( 0==Tcl_GetCommandInfo(interp, zIter, &cmdInfo) ){
1682 Tcl_AppendResult(interp, "no such iter: ", Tcl_GetString(objv[2]), NULL);
1683 return TCL_ERROR;
1684 }
1685
1686 pIter = (struct TestChangeIter*)cmdInfo.objClientData;
1687
1688 rc = sqlite3changegroup_add_change(p->pGrp, pIter->pIter);
1689 if( rc!=SQLITE_OK ){
1690 rc = test_session_error(interp, rc, 0);
1691 }
1692 break;
1693 };
1694
1695 case 14: /* change_beginne */
1696 case 5: { /* change_begin */
1697 struct ChangeType {
1698 const char *zType;
1699 int eType;
1700 } aType[] = {
1701 { "INSERT", SQLITE_INSERT },
1702 { "UPDATE", SQLITE_UPDATE },
1703 { "DELETE", SQLITE_DELETE },
1704 { 0, 0 }
1705 };
1706 int eType = 0;
1707 const char *zTab = 0;
1708 int bIndirect;
1709 int iIdx = 0;
1710 char *zErr = 0;
1711 char **pz = ((iSub==5) ? &zErr : 0);
1712
1713 if( TCL_OK!=Tcl_GetIntFromObj(0, objv[2], &eType) ){
1714 rc = Tcl_GetIndexFromObjStruct(
1715 interp, objv[2], aType, sizeof(aType[0]), "TYPE", 0, &iIdx
1716 );
1717 if( rc!=TCL_OK ) return rc;
1718 eType = aType[iIdx].eType;
1719 }
1720 zTab = Tcl_GetString(objv[3]);
1721 if( Tcl_GetBooleanFromObj(interp, objv[4], &bIndirect) ){
1722 return TCL_ERROR;
1723 }
1724
1725 rc = sqlite3changegroup_change_begin(p->pGrp, eType, zTab, bIndirect, pz);
1726 assert( zErr==0 || rc!=SQLITE_OK );
1727 if( rc!=SQLITE_OK ){
1728 rc = test_session_error(interp, rc, zErr);
1729 }
1730
1731 break;
1732 }
1733
1734 case 6: { /* change_int64 */
1735 int bNew = 0;
1736 int iCol = 0;
1737 sqlite3_int64 iVal = 0;
1738 if( TCL_OK!=testGetNewOrOld(interp, objv[2], &bNew)
1739 || TCL_OK!=Tcl_GetIntFromObj(interp, objv[3], &iCol)
1740 || TCL_OK!=Tcl_GetWideIntFromObj(interp, objv[4], &iVal)
1741 ){
1742 rc = TCL_ERROR;
1743 }else{
1744 rc = sqlite3changegroup_change_int64(p->pGrp, bNew, iCol, iVal);
1745 if( rc!=SQLITE_OK ){
1746 rc = test_session_error(interp, rc, 0);
1747 }
1748 }
1749 break;
1750 }
1751
1752 case 7: { /* change_null */
1753 int bNew = 0;
1754 int iCol = 0;
1755 if( TCL_OK!=testGetNewOrOld(interp, objv[2], &bNew)
1756 || TCL_OK!=Tcl_GetIntFromObj(interp, objv[3], &iCol)
1757 ){
1758 rc = TCL_ERROR;
1759 }else{
1760 rc = sqlite3changegroup_change_null(p->pGrp, bNew, iCol);
1761 if( rc!=SQLITE_OK ){
1762 rc = test_session_error(interp, rc, 0);
1763 }
1764 }
1765 break;
1766 }
1767
1768 case 8: { /* change_double */
1769 int bNew = 0;
1770 int iCol = 0;
1771 double rVal = 0;
1772 if( TCL_OK!=testGetNewOrOld(interp, objv[2], &bNew)
1773 || TCL_OK!=Tcl_GetIntFromObj(interp, objv[3], &iCol)
1774 || TCL_OK!=Tcl_GetDoubleFromObj(interp, objv[4], &rVal)
1775 ){
1776 rc = TCL_ERROR;
1777 }else{
1778 rc = sqlite3changegroup_change_double(p->pGrp, bNew, iCol, rVal);
1779 if( rc!=SQLITE_OK ){
1780 rc = test_session_error(interp, rc, 0);
1781 }
1782 }
1783 break;
1784 }
1785
1786 case 9: { /* change_text */
1787 int bNew = 0;
1788 int iCol = 0;
1789 if( TCL_OK!=testGetNewOrOld(interp, objv[2], &bNew)
1790 || TCL_OK!=Tcl_GetIntFromObj(interp, objv[3], &iCol)
1791 ){
1792 rc = TCL_ERROR;
1793 }else{
1794 Tcl_Size nVal = 0;
1795 const char *pVal = Tcl_GetStringFromObj(objv[4], &nVal);
1796 rc = sqlite3changegroup_change_text(p->pGrp, bNew, iCol, pVal, nVal);
1797 if( rc!=SQLITE_OK ){
1798 rc = test_session_error(interp, rc, 0);
1799 }
1800 }
1801 break;
1802 }
1803
1804 case 10: { /* change_blob */
1805 int bNew = 0;
1806 int iCol = 0;
1807 if( TCL_OK!=testGetNewOrOld(interp, objv[2], &bNew)
1808 || TCL_OK!=Tcl_GetIntFromObj(interp, objv[3], &iCol)
1809 ){
1810 rc = TCL_ERROR;
1811 }else{
1812 Tcl_Size nVal = 0;
1813 const u8 *pVal = Tcl_GetByteArrayFromObj(objv[4], &nVal);
1814 rc = sqlite3changegroup_change_blob(p->pGrp, bNew, iCol, pVal, nVal);
1815 if( rc!=SQLITE_OK ){
1816 rc = test_session_error(interp, rc, 0);
1817 }
1818 }
1819 break;
1820 }
1821
1822 case 11: { /* change_finish */
1823 int bDiscard = 0;
1824 if( TCL_OK!=Tcl_GetBooleanFromObj(interp, objv[2], &bDiscard) ){
1825 rc = TCL_ERROR;
1826 }else{
1827 char *zErr = 0;
1828 rc = sqlite3changegroup_change_finish(p->pGrp, bDiscard, &zErr);
1829 if( rc!=SQLITE_OK ){
1830 rc = test_session_error(interp, rc, zErr);
1831 }
1832 }
1833 break;
1834 }
1835
1836 case 12: { /* config */
1837 struct OptionName {
1838 const char *zOpt;
1839 int op;
1840 } aOp[] = {
1841 { "patchset", SQLITE_CHANGEGROUP_CONFIG_PATCHSET },
1842 { 0, 0 }
1843 };
1844 int iIdx = 0;
1845 int iArg = 0;
1846 rc = Tcl_GetIndexFromObjStruct(
1847 interp, objv[2], aOp, sizeof(aOp[0]), "option", 0, &iIdx
1848 );
1849 if( rc==TCL_OK
1850 && (rc = Tcl_GetIntFromObj(interp, objv[3], &iArg))==TCL_OK
1851 ){
1852 int op = aOp[iIdx].op;
1853 void *pArg = (void*)&iArg;
1854
1855 rc = sqlite3changegroup_config(p->pGrp, op, pArg);
1856 if( rc!=SQLITE_OK ){
1857 rc = test_session_error(interp, rc, 0);
1858 }else{
1859 Tcl_SetObjResult(interp, Tcl_NewIntObj(iArg));
1860 }
1861 }
1862 break;
1863 }
1864
1865 case 13: { /* change_text-1 */
1866 int bNew = 0;
1867 int iCol = 0;
1868 if( TCL_OK!=testGetNewOrOld(interp, objv[2], &bNew)
1869 || TCL_OK!=Tcl_GetIntFromObj(interp, objv[3], &iCol)
1870 ){
1871 rc = TCL_ERROR;
1872 }else{
1873 const char *pVal = Tcl_GetString(objv[4]);
1874 rc = sqlite3changegroup_change_text(p->pGrp, bNew, iCol, pVal, -1);
1875 if( rc!=SQLITE_OK ){
1876 rc = test_session_error(interp, rc, 0);
1877 }
1878 }
1879 break;
1880 }
1881
1882 default: { /* delete */
1883 assert( iSub==3 );
1884 Tcl_DeleteCommand(interp, Tcl_GetString(objv[0]));
1885 break;
1886 }
1887 }
1888
1889 return rc;
1890 }
1891
1892 /*
1893 ** Tclcmd: sqlite3changegroup CMD
1894 */
1895 static int SQLITE_TCLAPI test_sqlite3changegroup(
1896 void * clientData,
1897 Tcl_Interp *interp,
1898 int objc,
1899 Tcl_Obj *CONST objv[]
1900 ){
1901 int rc; /* sqlite3changegroup_new() return code */
1902 TestChangegroup *p; /* New wrapper object */
1903
1904 if( objc!=2 ){
1905 Tcl_WrongNumArgs(interp, 1, objv, "CMD");
1906 return TCL_ERROR;
1907 }
1908
1909 p = (TestChangegroup*)ckalloc(sizeof(TestChangegroup));
1910 memset(p, 0, sizeof(TestChangegroup));
1911 rc = sqlite3changegroup_new(&p->pGrp);
1912 if( rc!=SQLITE_OK ){
1913 ckfree((char*)p);
1914 return test_session_error(interp, rc, 0);
1915 }
1916
1917 Tcl_CreateObjCommand(
1918 interp, Tcl_GetString(objv[1]), test_changegroup_cmd, (ClientData)p,
1919 test_changegroup_del
1920 );
1921 Tcl_SetObjResult(interp, objv[1]);
1922 return TCL_OK;
1923 }
1924
1925 extern const char *sqlite3ErrName(int);
1926
1927 /*
1928 ** Destructor for Tcl iterator command object.
1929 */
1930 static void test_iter_del(void *clientData){
1931 TestChangeIter *p = (TestChangeIter*)clientData;
1932 sqlite3changeset_finalize(p->pIter);
1933 ckfree(p);
1934 }
1935
1936 static int SQLITE_TCLAPI test_iter_cmd(
1937 void * clientData,
1938 Tcl_Interp *interp,
1939 int objc,
1940 Tcl_Obj *CONST objv[]
1941 ){
1942 static const char *aSub[] = {
1943 "next", /* 0 */
1944 "data", /* 1 */
1945 "finalize", /* 2 */
1946 0
1947 };
1948 int iSub = 0;
1949
1950 TestChangeIter *p = (TestChangeIter*)clientData;
1951 int rc = SQLITE_OK;
1952
1953 if( objc<2 ){
1954 Tcl_WrongNumArgs(interp, 1, objv, "CMD");
1955 return TCL_ERROR;
1956 }
1957
1958 if( Tcl_GetIndexFromObj(interp, objv[1], aSub, "sub-command", 0, &iSub) ){
1959 return TCL_ERROR;
1960 }
1961 switch( iSub ){
1962 case 0:
1963 rc = sqlite3changeset_next(p->pIter);
1964 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
1965 break;
1966 case 1:
1967 Tcl_SetObjResult(interp, testIterData(p->pIter));
1968 break;
1969 case 2:
1970 rc = sqlite3changeset_finalize(p->pIter);
1971 p->pIter = 0;
1972 Tcl_DeleteCommand(interp, Tcl_GetString(objv[0]));
1973 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
1974 break;
1975 default:
1976 assert( 0 );
1977 break;
1978 }
1979
1980 return TCL_OK;
1981 }
1982
1983 /*
1984 ** Tclcmd: sqlite3changeset_start ?-invert? CHANGESET
1985 */
1986 static int SQLITE_TCLAPI test_sqlite3changeset_start(
1987 void * clientData,
1988 Tcl_Interp *interp,
1989 int objc,
1990 Tcl_Obj *CONST objv[]
1991 ){
1992 int isInvert = 0;
1993 void *pChangeset = 0; /* Buffer containing changeset */
1994 Tcl_Size nChangeset = 0; /* Size of buffer aChangeset in bytes */
1995 TestChangeIter *pNew = 0;
1996 sqlite3_changeset_iter *pIter = 0;
1997 int flags = 0;
1998 int rc = SQLITE_OK;
1999 int nAlloc = 0; /* Bytes of space to allocate */
2000
2001 static int iCmd = 1;
2002 char zCmd[64];
2003
2004 if( objc==3 ){
2005 Tcl_Size n = 0;
2006 const char *z = Tcl_GetStringFromObj(objv[1], &n);
2007 isInvert = (n>=2 && sqlite3_strnicmp(z, "-invert", (int)n)==0);
2008 }
2009
2010 if( objc!=2 && (objc!=3 || !isInvert) ){
2011 Tcl_WrongNumArgs(interp, 1, objv, "?-invert? CHANGESET");
2012 return TCL_ERROR;
2013 }
2014
2015 pChangeset = (void *)Tcl_GetByteArrayFromObj(objv[objc-1], &nChangeset);
2016 flags = isInvert ? SQLITE_CHANGESETSTART_INVERT : 0;
2017
2018 nAlloc = sizeof(TestChangeIter);
2019 if( test_tcl_integer(interp, SESSION_STREAM_TCL_VAR) ){
2020 nAlloc += nChangeset;
2021 }
2022 pNew = (TestChangeIter*)ckalloc(nAlloc);
2023 memset(pNew, 0, nAlloc);
2024 if( test_tcl_integer(interp, SESSION_STREAM_TCL_VAR) ){
2025 pNew->in.nStream = test_tcl_integer(interp, SESSION_STREAM_TCL_VAR);
2026 pNew->in.nData = nChangeset;
2027 pNew->in.aData = (unsigned char*)&pNew[1];
2028 memcpy(pNew->in.aData, pChangeset, nChangeset);
2029 }
2030
2031 if( pNew->in.nStream ){
2032 void *pCtx = (void*)&pNew->in;
2033 rc = sqlite3changeset_start_v2_strm(&pIter, testStreamInput, pCtx, flags);
2034 }else{
2035 rc = sqlite3changeset_start_v2(&pIter, (int)nChangeset, pChangeset, flags);
2036 }
2037 if( rc!=SQLITE_OK ){
2038 char *zErr = sqlite3_mprintf(
2039 "error in sqlite3changeset_start_v2() - %d", rc
2040 );
2041 Tcl_AppendResult(interp, zErr, (char*)0);
2042 ckfree(pNew);
2043 return TCL_ERROR;
2044 }
2045 pNew->pIter = pIter;
2046
2047 sprintf(zCmd, "csiter%d", iCmd++);
2048 Tcl_CreateObjCommand(interp, zCmd, test_iter_cmd, (void*)pNew, test_iter_del);
2049 Tcl_SetObjResult(interp, Tcl_NewStringObj(zCmd, -1));
2050 return TCL_OK;
2051 }
2052
2053 int TestSession_Init(Tcl_Interp *interp){
2054 struct Cmd {
2055 const char *zCmd;
2056 Tcl_ObjCmdProc *xProc;
2057 } aCmd[] = {
2058 { "sqlite3session", test_sqlite3session },
2059 { "sqlite3changegroup", test_sqlite3changegroup },
2060 { "sqlite3changeset_start", test_sqlite3changeset_start },
2061 { "sqlite3session_foreach", test_sqlite3session_foreach },
2062 { "sqlite3changeset_invert", test_sqlite3changeset_invert },
2063 { "sqlite3changeset_concat", test_sqlite3changeset_concat },
2064 { "sqlite3changeset_apply", test_sqlite3changeset_apply },
2065 { "sqlite3changeset_apply_v2", test_sqlite3changeset_apply_v2 },
2066 { "sqlite3changeset_apply_v3", test_sqlite3changeset_apply_v3 },
2067 { "sqlite3changeset_apply_replace_all",
2068 test_sqlite3changeset_apply_replace_all },
2069 { "sql_exec_changeset", test_sql_exec_changeset },
2070 { "sqlite3rebaser_create", test_sqlite3rebaser_create },
2071 { "sqlite3session_config", test_sqlite3session_config },
2072 { "test_changeset", test_changeset },
2073 };
2074 int i;
2075
2076 for(i=0; i<sizeof(aCmd)/sizeof(struct Cmd); i++){
2077 struct Cmd *p = &aCmd[i];
2078 Tcl_CreateObjCommand(interp, p->zCmd, p->xProc, 0, 0);
2079 }
2080
2081 return TCL_OK;
2082 }
2083
2084 #endif /* SQLITE_TEST && SQLITE_SESSION && SQLITE_PREUPDATE_HOOK */