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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 722 int Sqlitetest7_Init(Tcl_Interp *interp){ return TCL_OK; } 723 #endif /* SQLITE_OS_UNIX */ 724
