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