aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/libraries/sqlite/unix/sqlite-3.5.1/src/test7.c
diff options
context:
space:
mode:
authordan miller2007-10-21 08:36:32 +0000
committerdan miller2007-10-21 08:36:32 +0000
commit2f8d7092bc2c9609fa98d6888106b96f38b22828 (patch)
treeda6c37579258cc965b52a75aee6135fe44237698 /libraries/sqlite/unix/sqlite-3.5.1/src/test7.c
parent* Committing new PolicyManager based on an ACL system. (diff)
downloadopensim-SC-2f8d7092bc2c9609fa98d6888106b96f38b22828.zip
opensim-SC-2f8d7092bc2c9609fa98d6888106b96f38b22828.tar.gz
opensim-SC-2f8d7092bc2c9609fa98d6888106b96f38b22828.tar.bz2
opensim-SC-2f8d7092bc2c9609fa98d6888106b96f38b22828.tar.xz
libraries moved to opensim-libs, a new repository
Diffstat (limited to 'libraries/sqlite/unix/sqlite-3.5.1/src/test7.c')
-rw-r--r--libraries/sqlite/unix/sqlite-3.5.1/src/test7.c724
1 files changed, 0 insertions, 724 deletions
diff --git a/libraries/sqlite/unix/sqlite-3.5.1/src/test7.c b/libraries/sqlite/unix/sqlite-3.5.1/src/test7.c
deleted file mode 100644
index 8e2153a..0000000
--- a/libraries/sqlite/unix/sqlite-3.5.1/src/test7.c
+++ /dev/null
@@ -1,724 +0,0 @@
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** $Id: test7.c,v 1.9 2007/09/12 17:01:45 danielk1977 Exp $
16*/
17#include "sqliteInt.h"
18#include "tcl.h"
19
20/*
21** This test only works on UNIX with a SQLITE_THREADSAFE build that includes
22** the SQLITE_SERVER option.
23*/
24#if defined(SQLITE_SERVER) && !defined(SQLITE_OMIT_SHARED_CACHE)
25#if defined(OS_UNIX) && OS_UNIX && SQLITE_THREADSAFE
26
27#include <stdlib.h>
28#include <string.h>
29#include <pthread.h>
30#include <sched.h>
31#include <ctype.h>
32
33/*
34** Interfaces defined in server.c
35*/
36int sqlite3_client_open(const char*, sqlite3**);
37int sqlite3_client_prepare(sqlite3*,const char*,int,
38 sqlite3_stmt**,const char**);
39int sqlite3_client_step(sqlite3_stmt*);
40int sqlite3_client_reset(sqlite3_stmt*);
41int sqlite3_client_finalize(sqlite3_stmt*);
42int sqlite3_client_close(sqlite3*);
43int sqlite3_server_start(void);
44int sqlite3_server_stop(void);
45
46/*
47** Each thread is controlled by an instance of the following
48** structure.
49*/
50typedef struct Thread Thread;
51struct Thread {
52 /* The first group of fields are writable by the supervisor thread
53 ** and read-only to the client threads
54 */
55 char *zFilename; /* Name of database file */
56 void (*xOp)(Thread*); /* next operation to do */
57 char *zArg; /* argument usable by xOp */
58 volatile int opnum; /* Operation number */
59 volatile int busy; /* True if this thread is in use */
60
61 /* The next group of fields are writable by the client threads
62 ** but read-only to the superviser thread.
63 */
64 volatile int completed; /* Number of operations completed */
65 sqlite3 *db; /* Open database */
66 sqlite3_stmt *pStmt; /* Pending operation */
67 char *zErr; /* operation error */
68 char *zStaticErr; /* Static error message */
69 int rc; /* operation return code */
70 int argc; /* number of columns in result */
71 const char *argv[100]; /* result columns */
72 const char *colv[100]; /* result column names */
73};
74
75/*
76** There can be as many as 26 threads running at once. Each is named
77** by a capital letter: A, B, C, ..., Y, Z.
78*/
79#define N_THREAD 26
80static Thread threadset[N_THREAD];
81
82/*
83** The main loop for a thread. Threads use busy waiting.
84*/
85static void *client_main(void *pArg){
86 Thread *p = (Thread*)pArg;
87 if( p->db ){
88 sqlite3_client_close(p->db);
89 }
90 sqlite3_client_open(p->zFilename, &p->db);
91 if( SQLITE_OK!=sqlite3_errcode(p->db) ){
92 p->zErr = strdup(sqlite3_errmsg(p->db));
93 sqlite3_client_close(p->db);
94 p->db = 0;
95 }
96 p->pStmt = 0;
97 p->completed = 1;
98 while( p->opnum<=p->completed ) sched_yield();
99 while( p->xOp ){
100 if( p->zErr && p->zErr!=p->zStaticErr ){
101 sqlite3_free(p->zErr);
102 p->zErr = 0;
103 }
104 (*p->xOp)(p);
105 p->completed++;
106 while( p->opnum<=p->completed ) sched_yield();
107 }
108 if( p->pStmt ){
109 sqlite3_client_finalize(p->pStmt);
110 p->pStmt = 0;
111 }
112 if( p->db ){
113 sqlite3_client_close(p->db);
114 p->db = 0;
115 }
116 if( p->zErr && p->zErr!=p->zStaticErr ){
117 sqlite3_free(p->zErr);
118 p->zErr = 0;
119 }
120 p->completed++;
121 sqlite3_thread_cleanup();
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*/
130static 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*/
144static 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 = sqlite3StrDup(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*/
185static 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*/
194static 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*/
220static 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*/
238static 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*/
281static 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*/
313static 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*/
349static 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*/
385static 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*/
444static 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*/
471static 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*/
489static 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 = sqlite3StrDup(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*/
518static 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*/
542static 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*/
569static 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*/
584static 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*/
613static 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*/
628static 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*/
659static 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*/
695int 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
722int Sqlitetest7_Init(Tcl_Interp *interp){ return TCL_OK; }
723#endif /* OS_UNIX */
724#endif
generated by cgit v1.1 at 2025-02-10 14:22:37 +0000