1 /*
2 ** 2006 January 09
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 ** Code for testing the client/server version of the SQLite library.
13 ** Derived from test4.c.
14 */
15 #include "sqliteInt.h"
16 #include "tcl.h"
17
18 /*
19 ** This test only works on UNIX with a SQLITE_THREADSAFE build that includes
20 ** the SQLITE_SERVER option.
21 */
22 #if defined(SQLITE_SERVER) && !defined(SQLITE_OMIT_SHARED_CACHE) && \
23 SQLITE_OS_UNIX && SQLITE_THREADSAFE
24
25 #include <stdlib.h>
26 #include <string.h>
27 #include <pthread.h>
28 #include <sched.h>
29 #include <ctype.h>
30
31 /*
32 ** Interfaces defined in server.c
33 */
34 int sqlite3_client_open(const char*, sqlite3**);
35 int sqlite3_client_prepare(sqlite3*,const char*,int,
36 sqlite3_stmt**,const char**);
37 int sqlite3_client_step(sqlite3_stmt*);
38 int sqlite3_client_reset(sqlite3_stmt*);
39 int sqlite3_client_finalize(sqlite3_stmt*);
40 int sqlite3_client_close(sqlite3*);
41 int sqlite3_server_start(void);
42 int sqlite3_server_stop(void);
43
44 /*
45 ** Each thread is controlled by an instance of the following
46 ** structure.
47 */
48 typedef struct Thread Thread;
49 struct Thread {
50 /* The first group of fields are writable by the supervisor thread
51 ** and read-only to the client threads
52 */
53 char *zFilename; /* Name of database file */
54 void (*xOp)(Thread*); /* next operation to do */
55 char *zArg; /* argument usable by xOp */
56 volatile int opnum; /* Operation number */
57 volatile int busy; /* True if this thread is in use */
58
59 /* The next group of fields are writable by the client threads
60 ** but read-only to the superviser thread.
61 */
62 volatile int completed; /* Number of operations completed */
63 sqlite3 *db; /* Open database */
64 sqlite3_stmt *pStmt; /* Pending operation */
65 char *zErr; /* operation error */
66 char *zStaticErr; /* Static error message */
67 int rc; /* operation return code */
68 int argc; /* number of columns in result */
69 const char *argv[100]; /* result columns */
70 const char *colv[100]; /* result column names */
71 };
72
73 /*
74 ** There can be as many as 26 threads running at once. Each is named
75 ** by a capital letter: A, B, C, ..., Y, Z.
76 */
77 #define N_THREAD 26
78 static Thread threadset[N_THREAD];
79
80 /*
81 ** The main loop for a thread. Threads use busy waiting.
82 */
client_main(void * pArg)83 static void *client_main(void *pArg){
84 Thread *p = (Thread*)pArg;
85 if( p->db ){
86 sqlite3_client_close(p->db);
87 }
88 sqlite3_client_open(p->zFilename, &p->db);
89 if( SQLITE_OK!=sqlite3_errcode(p->db) ){
90 p->zErr = strdup(sqlite3_errmsg(p->db));
91 sqlite3_client_close(p->db);
92 p->db = 0;
93 }
94 p->pStmt = 0;
95 p->completed = 1;
96 while( p->opnum<=p->completed ) sched_yield();
97 while( p->xOp ){
98 if( p->zErr && p->zErr!=p->zStaticErr ){
99 sqlite3_free(p->zErr);
100 p->zErr = 0;
101 }
102 (*p->xOp)(p);
103 p->completed++;
104 while( p->opnum<=p->completed ) sched_yield();
105 }
106 if( p->pStmt ){
107 sqlite3_client_finalize(p->pStmt);
108 p->pStmt = 0;
109 }
110 if( p->db ){
111 sqlite3_client_close(p->db);
112 p->db = 0;
113 }
114 if( p->zErr && p->zErr!=p->zStaticErr ){
115 sqlite3_free(p->zErr);
116 p->zErr = 0;
117 }
118 p->completed++;
119 #ifndef SQLITE_OMIT_DEPRECATED
120 sqlite3_thread_cleanup();
121 #endif
122 return 0;
123 }
124
125 /*
126 ** Get a thread ID which is an upper case letter. Return the index.
127 ** If the argument is not a valid thread ID put an error message in
128 ** the interpreter and return -1.
129 */
parse_client_id(Tcl_Interp * interp,const char * zArg)130 static int parse_client_id(Tcl_Interp *interp, const char *zArg){
131 if( zArg==0 || zArg[0]==0 || zArg[1]!=0 || !isupper((unsigned char)zArg[0]) ){
132 Tcl_AppendResult(interp, "thread ID must be an upper case letter", 0);
133 return -1;
134 }
135 return zArg[0] - 'A';
136 }
137
138 /*
139 ** Usage: client_create NAME FILENAME
140 **
141 ** NAME should be an upper case letter. Start the thread running with
142 ** an open connection to the given database.
143 */
tcl_client_create(void * NotUsed,Tcl_Interp * interp,int argc,const char ** argv)144 static int tcl_client_create(
145 void *NotUsed,
146 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
147 int argc, /* Number of arguments */
148 const char **argv /* Text of each argument */
149 ){
150 int i;
151 pthread_t x;
152 int rc;
153
154 if( argc!=3 ){
155 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
156 " ID FILENAME", 0);
157 return TCL_ERROR;
158 }
159 i = parse_client_id(interp, argv[1]);
160 if( i<0 ) return TCL_ERROR;
161 if( threadset[i].busy ){
162 Tcl_AppendResult(interp, "thread ", argv[1], " is already running", 0);
163 return TCL_ERROR;
164 }
165 threadset[i].busy = 1;
166 sqlite3_free(threadset[i].zFilename);
167 threadset[i].zFilename = sqlite3_mprintf("%s", argv[2]);
168 threadset[i].opnum = 1;
169 threadset[i].completed = 0;
170 rc = pthread_create(&x, 0, client_main, &threadset[i]);
171 if( rc ){
172 Tcl_AppendResult(interp, "failed to create the thread", 0);
173 sqlite3_free(threadset[i].zFilename);
174 threadset[i].busy = 0;
175 return TCL_ERROR;
176 }
177 pthread_detach(x);
178 sqlite3_server_start();
179 return TCL_OK;
180 }
181
182 /*
183 ** Wait for a thread to reach its idle state.
184 */
client_wait(Thread * p)185 static void client_wait(Thread *p){
186 while( p->opnum>p->completed ) sched_yield();
187 }
188
189 /*
190 ** Usage: client_wait ID
191 **
192 ** Wait on thread ID to reach its idle state.
193 */
tcl_client_wait(void * NotUsed,Tcl_Interp * interp,int argc,const char ** argv)194 static int tcl_client_wait(
195 void *NotUsed,
196 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
197 int argc, /* Number of arguments */
198 const char **argv /* Text of each argument */
199 ){
200 int i;
201
202 if( argc!=2 ){
203 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
204 " ID", 0);
205 return TCL_ERROR;
206 }
207 i = parse_client_id(interp, argv[1]);
208 if( i<0 ) return TCL_ERROR;
209 if( !threadset[i].busy ){
210 Tcl_AppendResult(interp, "no such thread", 0);
211 return TCL_ERROR;
212 }
213 client_wait(&threadset[i]);
214 return TCL_OK;
215 }
216
217 /*
218 ** Stop a thread.
219 */
stop_thread(Thread * p)220 static void stop_thread(Thread *p){
221 client_wait(p);
222 p->xOp = 0;
223 p->opnum++;
224 client_wait(p);
225 sqlite3_free(p->zArg);
226 p->zArg = 0;
227 sqlite3_free(p->zFilename);
228 p->zFilename = 0;
229 p->busy = 0;
230 }
231
232 /*
233 ** Usage: client_halt ID
234 **
235 ** Cause a client thread to shut itself down. Wait for the shutdown to be
236 ** completed. If ID is "*" then stop all client threads.
237 */
tcl_client_halt(void * NotUsed,Tcl_Interp * interp,int argc,const char ** argv)238 static int tcl_client_halt(
239 void *NotUsed,
240 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
241 int argc, /* Number of arguments */
242 const char **argv /* Text of each argument */
243 ){
244 int i;
245
246 if( argc!=2 ){
247 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
248 " ID", 0);
249 return TCL_ERROR;
250 }
251 if( argv[1][0]=='*' && argv[1][1]==0 ){
252 for(i=0; i<N_THREAD; i++){
253 if( threadset[i].busy ){
254 stop_thread(&threadset[i]);
255 }
256 }
257 }else{
258 i = parse_client_id(interp, argv[1]);
259 if( i<0 ) return TCL_ERROR;
260 if( !threadset[i].busy ){
261 Tcl_AppendResult(interp, "no such thread", 0);
262 return TCL_ERROR;
263 }
264 stop_thread(&threadset[i]);
265 }
266
267 /* If no client threads are still running, also stop the server */
268 for(i=0; i<N_THREAD && threadset[i].busy==0; i++){}
269 if( i>=N_THREAD ){
270 sqlite3_server_stop();
271 }
272 return TCL_OK;
273 }
274
275 /*
276 ** Usage: client_argc ID
277 **
278 ** Wait on the most recent client_step to complete, then return the
279 ** number of columns in the result set.
280 */
tcl_client_argc(void * NotUsed,Tcl_Interp * interp,int argc,const char ** argv)281 static int tcl_client_argc(
282 void *NotUsed,
283 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
284 int argc, /* Number of arguments */
285 const char **argv /* Text of each argument */
286 ){
287 int i;
288 char zBuf[100];
289
290 if( argc!=2 ){
291 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
292 " ID", 0);
293 return TCL_ERROR;
294 }
295 i = parse_client_id(interp, argv[1]);
296 if( i<0 ) return TCL_ERROR;
297 if( !threadset[i].busy ){
298 Tcl_AppendResult(interp, "no such thread", 0);
299 return TCL_ERROR;
300 }
301 client_wait(&threadset[i]);
302 sprintf(zBuf, "%d", threadset[i].argc);
303 Tcl_AppendResult(interp, zBuf, 0);
304 return TCL_OK;
305 }
306
307 /*
308 ** Usage: client_argv ID N
309 **
310 ** Wait on the most recent client_step to complete, then return the
311 ** value of the N-th columns in the result set.
312 */
tcl_client_argv(void * NotUsed,Tcl_Interp * interp,int argc,const char ** argv)313 static int tcl_client_argv(
314 void *NotUsed,
315 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
316 int argc, /* Number of arguments */
317 const char **argv /* Text of each argument */
318 ){
319 int i;
320 int n;
321
322 if( argc!=3 ){
323 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
324 " ID N", 0);
325 return TCL_ERROR;
326 }
327 i = parse_client_id(interp, argv[1]);
328 if( i<0 ) return TCL_ERROR;
329 if( !threadset[i].busy ){
330 Tcl_AppendResult(interp, "no such thread", 0);
331 return TCL_ERROR;
332 }
333 if( Tcl_GetInt(interp, argv[2], &n) ) return TCL_ERROR;
334 client_wait(&threadset[i]);
335 if( n<0 || n>=threadset[i].argc ){
336 Tcl_AppendResult(interp, "column number out of range", 0);
337 return TCL_ERROR;
338 }
339 Tcl_AppendResult(interp, threadset[i].argv[n], 0);
340 return TCL_OK;
341 }
342
343 /*
344 ** Usage: client_colname ID N
345 **
346 ** Wait on the most recent client_step to complete, then return the
347 ** name of the N-th columns in the result set.
348 */
tcl_client_colname(void * NotUsed,Tcl_Interp * interp,int argc,const char ** argv)349 static int tcl_client_colname(
350 void *NotUsed,
351 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
352 int argc, /* Number of arguments */
353 const char **argv /* Text of each argument */
354 ){
355 int i;
356 int n;
357
358 if( argc!=3 ){
359 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
360 " ID N", 0);
361 return TCL_ERROR;
362 }
363 i = parse_client_id(interp, argv[1]);
364 if( i<0 ) return TCL_ERROR;
365 if( !threadset[i].busy ){
366 Tcl_AppendResult(interp, "no such thread", 0);
367 return TCL_ERROR;
368 }
369 if( Tcl_GetInt(interp, argv[2], &n) ) return TCL_ERROR;
370 client_wait(&threadset[i]);
371 if( n<0 || n>=threadset[i].argc ){
372 Tcl_AppendResult(interp, "column number out of range", 0);
373 return TCL_ERROR;
374 }
375 Tcl_AppendResult(interp, threadset[i].colv[n], 0);
376 return TCL_OK;
377 }
378
379 /*
380 ** Usage: client_result ID
381 **
382 ** Wait on the most recent operation to complete, then return the
383 ** result code from that operation.
384 */
tcl_client_result(void * NotUsed,Tcl_Interp * interp,int argc,const char ** argv)385 static int tcl_client_result(
386 void *NotUsed,
387 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
388 int argc, /* Number of arguments */
389 const char **argv /* Text of each argument */
390 ){
391 int i;
392 const char *zName;
393
394 if( argc!=2 ){
395 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
396 " ID", 0);
397 return TCL_ERROR;
398 }
399 i = parse_client_id(interp, argv[1]);
400 if( i<0 ) return TCL_ERROR;
401 if( !threadset[i].busy ){
402 Tcl_AppendResult(interp, "no such thread", 0);
403 return TCL_ERROR;
404 }
405 client_wait(&threadset[i]);
406 switch( threadset[i].rc ){
407 case SQLITE_OK: zName = "SQLITE_OK"; break;
408 case SQLITE_ERROR: zName = "SQLITE_ERROR"; break;
409 case SQLITE_PERM: zName = "SQLITE_PERM"; break;
410 case SQLITE_ABORT: zName = "SQLITE_ABORT"; break;
411 case SQLITE_BUSY: zName = "SQLITE_BUSY"; break;
412 case SQLITE_LOCKED: zName = "SQLITE_LOCKED"; break;
413 case SQLITE_NOMEM: zName = "SQLITE_NOMEM"; break;
414 case SQLITE_READONLY: zName = "SQLITE_READONLY"; break;
415 case SQLITE_INTERRUPT: zName = "SQLITE_INTERRUPT"; break;
416 case SQLITE_IOERR: zName = "SQLITE_IOERR"; break;
417 case SQLITE_CORRUPT: zName = "SQLITE_CORRUPT"; break;
418 case SQLITE_FULL: zName = "SQLITE_FULL"; break;
419 case SQLITE_CANTOPEN: zName = "SQLITE_CANTOPEN"; break;
420 case SQLITE_PROTOCOL: zName = "SQLITE_PROTOCOL"; break;
421 case SQLITE_EMPTY: zName = "SQLITE_EMPTY"; break;
422 case SQLITE_SCHEMA: zName = "SQLITE_SCHEMA"; break;
423 case SQLITE_CONSTRAINT: zName = "SQLITE_CONSTRAINT"; break;
424 case SQLITE_MISMATCH: zName = "SQLITE_MISMATCH"; break;
425 case SQLITE_MISUSE: zName = "SQLITE_MISUSE"; break;
426 case SQLITE_NOLFS: zName = "SQLITE_NOLFS"; break;
427 case SQLITE_AUTH: zName = "SQLITE_AUTH"; break;
428 case SQLITE_FORMAT: zName = "SQLITE_FORMAT"; break;
429 case SQLITE_RANGE: zName = "SQLITE_RANGE"; break;
430 case SQLITE_ROW: zName = "SQLITE_ROW"; break;
431 case SQLITE_DONE: zName = "SQLITE_DONE"; break;
432 default: zName = "SQLITE_Unknown"; break;
433 }
434 Tcl_AppendResult(interp, zName, 0);
435 return TCL_OK;
436 }
437
438 /*
439 ** Usage: client_error ID
440 **
441 ** Wait on the most recent operation to complete, then return the
442 ** error string.
443 */
tcl_client_error(void * NotUsed,Tcl_Interp * interp,int argc,const char ** argv)444 static int tcl_client_error(
445 void *NotUsed,
446 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
447 int argc, /* Number of arguments */
448 const char **argv /* Text of each argument */
449 ){
450 int i;
451
452 if( argc!=2 ){
453 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
454 " ID", 0);
455 return TCL_ERROR;
456 }
457 i = parse_client_id(interp, argv[1]);
458 if( i<0 ) return TCL_ERROR;
459 if( !threadset[i].busy ){
460 Tcl_AppendResult(interp, "no such thread", 0);
461 return TCL_ERROR;
462 }
463 client_wait(&threadset[i]);
464 Tcl_AppendResult(interp, threadset[i].zErr, 0);
465 return TCL_OK;
466 }
467
468 /*
469 ** This procedure runs in the thread to compile an SQL statement.
470 */
do_compile(Thread * p)471 static void do_compile(Thread *p){
472 if( p->db==0 ){
473 p->zErr = p->zStaticErr = "no database is open";
474 p->rc = SQLITE_ERROR;
475 return;
476 }
477 if( p->pStmt ){
478 sqlite3_client_finalize(p->pStmt);
479 p->pStmt = 0;
480 }
481 p->rc = sqlite3_client_prepare(p->db, p->zArg, -1, &p->pStmt, 0);
482 }
483
484 /*
485 ** Usage: client_compile ID SQL
486 **
487 ** Compile a new virtual machine.
488 */
tcl_client_compile(void * NotUsed,Tcl_Interp * interp,int argc,const char ** argv)489 static int tcl_client_compile(
490 void *NotUsed,
491 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
492 int argc, /* Number of arguments */
493 const char **argv /* Text of each argument */
494 ){
495 int i;
496 if( argc!=3 ){
497 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
498 " ID SQL", 0);
499 return TCL_ERROR;
500 }
501 i = parse_client_id(interp, argv[1]);
502 if( i<0 ) return TCL_ERROR;
503 if( !threadset[i].busy ){
504 Tcl_AppendResult(interp, "no such thread", 0);
505 return TCL_ERROR;
506 }
507 client_wait(&threadset[i]);
508 threadset[i].xOp = do_compile;
509 sqlite3_free(threadset[i].zArg);
510 threadset[i].zArg = sqlite3_mprintf("%s", argv[2]);
511 threadset[i].opnum++;
512 return TCL_OK;
513 }
514
515 /*
516 ** This procedure runs in the thread to step the virtual machine.
517 */
do_step(Thread * p)518 static void do_step(Thread *p){
519 int i;
520 if( p->pStmt==0 ){
521 p->zErr = p->zStaticErr = "no virtual machine available";
522 p->rc = SQLITE_ERROR;
523 return;
524 }
525 p->rc = sqlite3_client_step(p->pStmt);
526 if( p->rc==SQLITE_ROW ){
527 p->argc = sqlite3_column_count(p->pStmt);
528 for(i=0; i<sqlite3_data_count(p->pStmt); i++){
529 p->argv[i] = (char*)sqlite3_column_text(p->pStmt, i);
530 }
531 for(i=0; i<p->argc; i++){
532 p->colv[i] = sqlite3_column_name(p->pStmt, i);
533 }
534 }
535 }
536
537 /*
538 ** Usage: client_step ID
539 **
540 ** Advance the virtual machine by one step
541 */
tcl_client_step(void * NotUsed,Tcl_Interp * interp,int argc,const char ** argv)542 static int tcl_client_step(
543 void *NotUsed,
544 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
545 int argc, /* Number of arguments */
546 const char **argv /* Text of each argument */
547 ){
548 int i;
549 if( argc!=2 ){
550 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
551 " IDL", 0);
552 return TCL_ERROR;
553 }
554 i = parse_client_id(interp, argv[1]);
555 if( i<0 ) return TCL_ERROR;
556 if( !threadset[i].busy ){
557 Tcl_AppendResult(interp, "no such thread", 0);
558 return TCL_ERROR;
559 }
560 client_wait(&threadset[i]);
561 threadset[i].xOp = do_step;
562 threadset[i].opnum++;
563 return TCL_OK;
564 }
565
566 /*
567 ** This procedure runs in the thread to finalize a virtual machine.
568 */
do_finalize(Thread * p)569 static void do_finalize(Thread *p){
570 if( p->pStmt==0 ){
571 p->zErr = p->zStaticErr = "no virtual machine available";
572 p->rc = SQLITE_ERROR;
573 return;
574 }
575 p->rc = sqlite3_client_finalize(p->pStmt);
576 p->pStmt = 0;
577 }
578
579 /*
580 ** Usage: client_finalize ID
581 **
582 ** Finalize the virtual machine.
583 */
tcl_client_finalize(void * NotUsed,Tcl_Interp * interp,int argc,const char ** argv)584 static int tcl_client_finalize(
585 void *NotUsed,
586 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
587 int argc, /* Number of arguments */
588 const char **argv /* Text of each argument */
589 ){
590 int i;
591 if( argc!=2 ){
592 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
593 " IDL", 0);
594 return TCL_ERROR;
595 }
596 i = parse_client_id(interp, argv[1]);
597 if( i<0 ) return TCL_ERROR;
598 if( !threadset[i].busy ){
599 Tcl_AppendResult(interp, "no such thread", 0);
600 return TCL_ERROR;
601 }
602 client_wait(&threadset[i]);
603 threadset[i].xOp = do_finalize;
604 sqlite3_free(threadset[i].zArg);
605 threadset[i].zArg = 0;
606 threadset[i].opnum++;
607 return TCL_OK;
608 }
609
610 /*
611 ** This procedure runs in the thread to reset a virtual machine.
612 */
do_reset(Thread * p)613 static void do_reset(Thread *p){
614 if( p->pStmt==0 ){
615 p->zErr = p->zStaticErr = "no virtual machine available";
616 p->rc = SQLITE_ERROR;
617 return;
618 }
619 p->rc = sqlite3_client_reset(p->pStmt);
620 p->pStmt = 0;
621 }
622
623 /*
624 ** Usage: client_reset ID
625 **
626 ** Finalize the virtual machine.
627 */
tcl_client_reset(void * NotUsed,Tcl_Interp * interp,int argc,const char ** argv)628 static int tcl_client_reset(
629 void *NotUsed,
630 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
631 int argc, /* Number of arguments */
632 const char **argv /* Text of each argument */
633 ){
634 int i;
635 if( argc!=2 ){
636 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
637 " IDL", 0);
638 return TCL_ERROR;
639 }
640 i = parse_client_id(interp, argv[1]);
641 if( i<0 ) return TCL_ERROR;
642 if( !threadset[i].busy ){
643 Tcl_AppendResult(interp, "no such thread", 0);
644 return TCL_ERROR;
645 }
646 client_wait(&threadset[i]);
647 threadset[i].xOp = do_reset;
648 sqlite3_free(threadset[i].zArg);
649 threadset[i].zArg = 0;
650 threadset[i].opnum++;
651 return TCL_OK;
652 }
653
654 /*
655 ** Usage: client_swap ID ID
656 **
657 ** Interchange the sqlite* pointer between two threads.
658 */
tcl_client_swap(void * NotUsed,Tcl_Interp * interp,int argc,const char ** argv)659 static int tcl_client_swap(
660 void *NotUsed,
661 Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
662 int argc, /* Number of arguments */
663 const char **argv /* Text of each argument */
664 ){
665 int i, j;
666 sqlite3 *temp;
667 if( argc!=3 ){
668 Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
669 " ID1 ID2", 0);
670 return TCL_ERROR;
671 }
672 i = parse_client_id(interp, argv[1]);
673 if( i<0 ) return TCL_ERROR;
674 if( !threadset[i].busy ){
675 Tcl_AppendResult(interp, "no such thread", 0);
676 return TCL_ERROR;
677 }
678 client_wait(&threadset[i]);
679 j = parse_client_id(interp, argv[2]);
680 if( j<0 ) return TCL_ERROR;
681 if( !threadset[j].busy ){
682 Tcl_AppendResult(interp, "no such thread", 0);
683 return TCL_ERROR;
684 }
685 client_wait(&threadset[j]);
686 temp = threadset[i].db;
687 threadset[i].db = threadset[j].db;
688 threadset[j].db = temp;
689 return TCL_OK;
690 }
691
692 /*
693 ** Register commands with the TCL interpreter.
694 */
Sqlitetest7_Init(Tcl_Interp * interp)695 int Sqlitetest7_Init(Tcl_Interp *interp){
696 static struct {
697 char *zName;
698 Tcl_CmdProc *xProc;
699 } aCmd[] = {
700 { "client_create", (Tcl_CmdProc*)tcl_client_create },
701 { "client_wait", (Tcl_CmdProc*)tcl_client_wait },
702 { "client_halt", (Tcl_CmdProc*)tcl_client_halt },
703 { "client_argc", (Tcl_CmdProc*)tcl_client_argc },
704 { "client_argv", (Tcl_CmdProc*)tcl_client_argv },
705 { "client_colname", (Tcl_CmdProc*)tcl_client_colname },
706 { "client_result", (Tcl_CmdProc*)tcl_client_result },
707 { "client_error", (Tcl_CmdProc*)tcl_client_error },
708 { "client_compile", (Tcl_CmdProc*)tcl_client_compile },
709 { "client_step", (Tcl_CmdProc*)tcl_client_step },
710 { "client_reset", (Tcl_CmdProc*)tcl_client_reset },
711 { "client_finalize", (Tcl_CmdProc*)tcl_client_finalize },
712 { "client_swap", (Tcl_CmdProc*)tcl_client_swap },
713 };
714 int i;
715
716 for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
717 Tcl_CreateCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);
718 }
719 return TCL_OK;
720 }
721 #else
Sqlitetest7_Init(Tcl_Interp * interp)722 int Sqlitetest7_Init(Tcl_Interp *interp){ return TCL_OK; }
723 #endif /* SQLITE_OS_UNIX */
724