Annotation of embedaddon/sqlite3/src/test_thread.c, revision 1.1.1.1
1.1 misho 1: /*
2: ** 2007 September 9
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: **
13: ** This file contains the implementation of some Tcl commands used to
14: ** test that sqlite3 database handles may be concurrently accessed by
15: ** multiple threads. Right now this only works on unix.
16: */
17:
18: #include "sqliteInt.h"
19: #include <tcl.h>
20:
21: #if SQLITE_THREADSAFE
22:
23: #include <errno.h>
24:
25: #if !defined(_MSC_VER)
26: #include <unistd.h>
27: #endif
28:
29: /*
30: ** One of these is allocated for each thread created by [sqlthread spawn].
31: */
32: typedef struct SqlThread SqlThread;
33: struct SqlThread {
34: Tcl_ThreadId parent; /* Thread id of parent thread */
35: Tcl_Interp *interp; /* Parent interpreter */
36: char *zScript; /* The script to execute. */
37: char *zVarname; /* Varname in parent script */
38: };
39:
40: /*
41: ** A custom Tcl_Event type used by this module. When the event is
42: ** handled, script zScript is evaluated in interpreter interp. If
43: ** the evaluation throws an exception (returns TCL_ERROR), then the
44: ** error is handled by Tcl_BackgroundError(). If no error occurs,
45: ** the result is simply discarded.
46: */
47: typedef struct EvalEvent EvalEvent;
48: struct EvalEvent {
49: Tcl_Event base; /* Base class of type Tcl_Event */
50: char *zScript; /* The script to execute. */
51: Tcl_Interp *interp; /* The interpreter to execute it in. */
52: };
53:
54: static Tcl_ObjCmdProc sqlthread_proc;
55: static Tcl_ObjCmdProc clock_seconds_proc;
56: #if SQLITE_OS_UNIX && defined(SQLITE_ENABLE_UNLOCK_NOTIFY)
57: static Tcl_ObjCmdProc blocking_step_proc;
58: static Tcl_ObjCmdProc blocking_prepare_v2_proc;
59: #endif
60: int Sqlitetest1_Init(Tcl_Interp *);
61: int Sqlite3_Init(Tcl_Interp *);
62:
63: /* Functions from test1.c */
64: void *sqlite3TestTextToPtr(const char *);
65: const char *sqlite3TestErrorName(int);
66: int getDbPointer(Tcl_Interp *, const char *, sqlite3 **);
67: int sqlite3TestMakePointerStr(Tcl_Interp *, char *, void *);
68: int sqlite3TestErrCode(Tcl_Interp *, sqlite3 *, int);
69:
70: /*
71: ** Handler for events of type EvalEvent.
72: */
73: static int tclScriptEvent(Tcl_Event *evPtr, int flags){
74: int rc;
75: EvalEvent *p = (EvalEvent *)evPtr;
76: rc = Tcl_Eval(p->interp, p->zScript);
77: if( rc!=TCL_OK ){
78: Tcl_BackgroundError(p->interp);
79: }
80: UNUSED_PARAMETER(flags);
81: return 1;
82: }
83:
84: /*
85: ** Register an EvalEvent to evaluate the script pScript in the
86: ** parent interpreter/thread of SqlThread p.
87: */
88: static void postToParent(SqlThread *p, Tcl_Obj *pScript){
89: EvalEvent *pEvent;
90: char *zMsg;
91: int nMsg;
92:
93: zMsg = Tcl_GetStringFromObj(pScript, &nMsg);
94: pEvent = (EvalEvent *)ckalloc(sizeof(EvalEvent)+nMsg+1);
95: pEvent->base.nextPtr = 0;
96: pEvent->base.proc = tclScriptEvent;
97: pEvent->zScript = (char *)&pEvent[1];
98: memcpy(pEvent->zScript, zMsg, nMsg+1);
99: pEvent->interp = p->interp;
100:
101: Tcl_ThreadQueueEvent(p->parent, (Tcl_Event *)pEvent, TCL_QUEUE_TAIL);
102: Tcl_ThreadAlert(p->parent);
103: }
104:
105: /*
106: ** The main function for threads created with [sqlthread spawn].
107: */
108: static Tcl_ThreadCreateType tclScriptThread(ClientData pSqlThread){
109: Tcl_Interp *interp;
110: Tcl_Obj *pRes;
111: Tcl_Obj *pList;
112: int rc;
113: SqlThread *p = (SqlThread *)pSqlThread;
114: extern int Sqlitetest_mutex_Init(Tcl_Interp*);
115:
116: interp = Tcl_CreateInterp();
117: Tcl_CreateObjCommand(interp, "clock_seconds", clock_seconds_proc, 0, 0);
118: Tcl_CreateObjCommand(interp, "sqlthread", sqlthread_proc, pSqlThread, 0);
119: #if SQLITE_OS_UNIX && defined(SQLITE_ENABLE_UNLOCK_NOTIFY)
120: Tcl_CreateObjCommand(interp, "sqlite3_blocking_step", blocking_step_proc,0,0);
121: Tcl_CreateObjCommand(interp,
122: "sqlite3_blocking_prepare_v2", blocking_prepare_v2_proc, (void *)1, 0);
123: Tcl_CreateObjCommand(interp,
124: "sqlite3_nonblocking_prepare_v2", blocking_prepare_v2_proc, 0, 0);
125: #endif
126: Sqlitetest1_Init(interp);
127: Sqlitetest_mutex_Init(interp);
128: Sqlite3_Init(interp);
129:
130: rc = Tcl_Eval(interp, p->zScript);
131: pRes = Tcl_GetObjResult(interp);
132: pList = Tcl_NewObj();
133: Tcl_IncrRefCount(pList);
134: Tcl_IncrRefCount(pRes);
135:
136: if( rc!=TCL_OK ){
137: Tcl_ListObjAppendElement(interp, pList, Tcl_NewStringObj("error", -1));
138: Tcl_ListObjAppendElement(interp, pList, pRes);
139: postToParent(p, pList);
140: Tcl_DecrRefCount(pList);
141: pList = Tcl_NewObj();
142: }
143:
144: Tcl_ListObjAppendElement(interp, pList, Tcl_NewStringObj("set", -1));
145: Tcl_ListObjAppendElement(interp, pList, Tcl_NewStringObj(p->zVarname, -1));
146: Tcl_ListObjAppendElement(interp, pList, pRes);
147: postToParent(p, pList);
148:
149: ckfree((void *)p);
150: Tcl_DecrRefCount(pList);
151: Tcl_DecrRefCount(pRes);
152: Tcl_DeleteInterp(interp);
153: while( Tcl_DoOneEvent(TCL_ALL_EVENTS|TCL_DONT_WAIT) );
154: Tcl_ExitThread(0);
155: TCL_THREAD_CREATE_RETURN;
156: }
157:
158: /*
159: ** sqlthread spawn VARNAME SCRIPT
160: **
161: ** Spawn a new thread with its own Tcl interpreter and run the
162: ** specified SCRIPT(s) in it. The thread terminates after running
163: ** the script. The result of the script is stored in the variable
164: ** VARNAME.
165: **
166: ** The caller can wait for the script to terminate using [vwait VARNAME].
167: */
168: static int sqlthread_spawn(
169: ClientData clientData,
170: Tcl_Interp *interp,
171: int objc,
172: Tcl_Obj *CONST objv[]
173: ){
174: Tcl_ThreadId x;
175: SqlThread *pNew;
176: int rc;
177:
178: int nVarname; char *zVarname;
179: int nScript; char *zScript;
180:
181: /* Parameters for thread creation */
182: const int nStack = TCL_THREAD_STACK_DEFAULT;
183: const int flags = TCL_THREAD_NOFLAGS;
184:
185: assert(objc==4);
186: UNUSED_PARAMETER(clientData);
187: UNUSED_PARAMETER(objc);
188:
189: zVarname = Tcl_GetStringFromObj(objv[2], &nVarname);
190: zScript = Tcl_GetStringFromObj(objv[3], &nScript);
191:
192: pNew = (SqlThread *)ckalloc(sizeof(SqlThread)+nVarname+nScript+2);
193: pNew->zVarname = (char *)&pNew[1];
194: pNew->zScript = (char *)&pNew->zVarname[nVarname+1];
195: memcpy(pNew->zVarname, zVarname, nVarname+1);
196: memcpy(pNew->zScript, zScript, nScript+1);
197: pNew->parent = Tcl_GetCurrentThread();
198: pNew->interp = interp;
199:
200: rc = Tcl_CreateThread(&x, tclScriptThread, (void *)pNew, nStack, flags);
201: if( rc!=TCL_OK ){
202: Tcl_AppendResult(interp, "Error in Tcl_CreateThread()", 0);
203: ckfree((char *)pNew);
204: return TCL_ERROR;
205: }
206:
207: return TCL_OK;
208: }
209:
210: /*
211: ** sqlthread parent SCRIPT
212: **
213: ** This can be called by spawned threads only. It sends the specified
214: ** script back to the parent thread for execution. The result of
215: ** evaluating the SCRIPT is returned. The parent thread must enter
216: ** the event loop for this to work - otherwise the caller will
217: ** block indefinitely.
218: **
219: ** NOTE: At the moment, this doesn't work. FIXME.
220: */
221: static int sqlthread_parent(
222: ClientData clientData,
223: Tcl_Interp *interp,
224: int objc,
225: Tcl_Obj *CONST objv[]
226: ){
227: EvalEvent *pEvent;
228: char *zMsg;
229: int nMsg;
230: SqlThread *p = (SqlThread *)clientData;
231:
232: assert(objc==3);
233: UNUSED_PARAMETER(objc);
234:
235: if( p==0 ){
236: Tcl_AppendResult(interp, "no parent thread", 0);
237: return TCL_ERROR;
238: }
239:
240: zMsg = Tcl_GetStringFromObj(objv[2], &nMsg);
241: pEvent = (EvalEvent *)ckalloc(sizeof(EvalEvent)+nMsg+1);
242: pEvent->base.nextPtr = 0;
243: pEvent->base.proc = tclScriptEvent;
244: pEvent->zScript = (char *)&pEvent[1];
245: memcpy(pEvent->zScript, zMsg, nMsg+1);
246: pEvent->interp = p->interp;
247: Tcl_ThreadQueueEvent(p->parent, (Tcl_Event *)pEvent, TCL_QUEUE_TAIL);
248: Tcl_ThreadAlert(p->parent);
249:
250: return TCL_OK;
251: }
252:
253: static int xBusy(void *pArg, int nBusy){
254: UNUSED_PARAMETER(pArg);
255: UNUSED_PARAMETER(nBusy);
256: sqlite3_sleep(50);
257: return 1; /* Try again... */
258: }
259:
260: /*
261: ** sqlthread open
262: **
263: ** Open a database handle and return the string representation of
264: ** the pointer value.
265: */
266: static int sqlthread_open(
267: ClientData clientData,
268: Tcl_Interp *interp,
269: int objc,
270: Tcl_Obj *CONST objv[]
271: ){
272: int sqlite3TestMakePointerStr(Tcl_Interp *interp, char *zPtr, void *p);
273:
274: const char *zFilename;
275: sqlite3 *db;
276: int rc;
277: char zBuf[100];
278: extern void Md5_Register(sqlite3*);
279:
280: UNUSED_PARAMETER(clientData);
281: UNUSED_PARAMETER(objc);
282:
283: zFilename = Tcl_GetString(objv[2]);
284: rc = sqlite3_open(zFilename, &db);
285: #ifdef SQLITE_HAS_CODEC
286: if( db && objc>=4 ){
287: const char *zKey;
288: int nKey;
289: zKey = Tcl_GetStringFromObj(objv[3], &nKey);
290: rc = sqlite3_key(db, zKey, nKey);
291: if( rc!=SQLITE_OK ){
292: char *zErrMsg = sqlite3_mprintf("error %d: %s", rc, sqlite3_errmsg(db));
293: sqlite3_close(db);
294: Tcl_AppendResult(interp, zErrMsg, (char*)0);
295: sqlite3_free(zErrMsg);
296: return TCL_ERROR;
297: }
298: }
299: #endif
300: Md5_Register(db);
301: sqlite3_busy_handler(db, xBusy, 0);
302:
303: if( sqlite3TestMakePointerStr(interp, zBuf, db) ) return TCL_ERROR;
304: Tcl_AppendResult(interp, zBuf, 0);
305:
306: return TCL_OK;
307: }
308:
309:
310: /*
311: ** sqlthread open
312: **
313: ** Return the current thread-id (Tcl_GetCurrentThread()) cast to
314: ** an integer.
315: */
316: static int sqlthread_id(
317: ClientData clientData,
318: Tcl_Interp *interp,
319: int objc,
320: Tcl_Obj *CONST objv[]
321: ){
322: Tcl_ThreadId id = Tcl_GetCurrentThread();
323: Tcl_SetObjResult(interp, Tcl_NewIntObj(SQLITE_PTR_TO_INT(id)));
324: UNUSED_PARAMETER(clientData);
325: UNUSED_PARAMETER(objc);
326: UNUSED_PARAMETER(objv);
327: return TCL_OK;
328: }
329:
330:
331: /*
332: ** Dispatch routine for the sub-commands of [sqlthread].
333: */
334: static int sqlthread_proc(
335: ClientData clientData,
336: Tcl_Interp *interp,
337: int objc,
338: Tcl_Obj *CONST objv[]
339: ){
340: struct SubCommand {
341: char *zName;
342: Tcl_ObjCmdProc *xProc;
343: int nArg;
344: char *zUsage;
345: } aSub[] = {
346: {"parent", sqlthread_parent, 1, "SCRIPT"},
347: {"spawn", sqlthread_spawn, 2, "VARNAME SCRIPT"},
348: {"open", sqlthread_open, 1, "DBNAME"},
349: {"id", sqlthread_id, 0, ""},
350: {0, 0, 0}
351: };
352: struct SubCommand *pSub;
353: int rc;
354: int iIndex;
355:
356: if( objc<2 ){
357: Tcl_WrongNumArgs(interp, 1, objv, "SUB-COMMAND");
358: return TCL_ERROR;
359: }
360:
361: rc = Tcl_GetIndexFromObjStruct(
362: interp, objv[1], aSub, sizeof(aSub[0]), "sub-command", 0, &iIndex
363: );
364: if( rc!=TCL_OK ) return rc;
365: pSub = &aSub[iIndex];
366:
367: if( objc<(pSub->nArg+2) ){
368: Tcl_WrongNumArgs(interp, 2, objv, pSub->zUsage);
369: return TCL_ERROR;
370: }
371:
372: return pSub->xProc(clientData, interp, objc, objv);
373: }
374:
375: /*
376: ** The [clock_seconds] command. This is more or less the same as the
377: ** regular tcl [clock seconds], except that it is available in testfixture
378: ** when linked against both Tcl 8.4 and 8.5. Because [clock seconds] is
379: ** implemented as a script in Tcl 8.5, it is not usually available to
380: ** testfixture.
381: */
382: static int clock_seconds_proc(
383: ClientData clientData,
384: Tcl_Interp *interp,
385: int objc,
386: Tcl_Obj *CONST objv[]
387: ){
388: Tcl_Time now;
389: Tcl_GetTime(&now);
390: Tcl_SetObjResult(interp, Tcl_NewIntObj(now.sec));
391: UNUSED_PARAMETER(clientData);
392: UNUSED_PARAMETER(objc);
393: UNUSED_PARAMETER(objv);
394: return TCL_OK;
395: }
396:
397: /*************************************************************************
398: ** This block contains the implementation of the [sqlite3_blocking_step]
399: ** command available to threads created by [sqlthread spawn] commands. It
400: ** is only available on UNIX for now. This is because pthread condition
401: ** variables are used.
402: **
403: ** The source code for the C functions sqlite3_blocking_step(),
404: ** blocking_step_notify() and the structure UnlockNotification is
405: ** automatically extracted from this file and used as part of the
406: ** documentation for the sqlite3_unlock_notify() API function. This
407: ** should be considered if these functions are to be extended (i.e. to
408: ** support windows) in the future.
409: */
410: #if SQLITE_OS_UNIX && defined(SQLITE_ENABLE_UNLOCK_NOTIFY)
411:
412: /* BEGIN_SQLITE_BLOCKING_STEP */
413: /* This example uses the pthreads API */
414: #include <pthread.h>
415:
416: /*
417: ** A pointer to an instance of this structure is passed as the user-context
418: ** pointer when registering for an unlock-notify callback.
419: */
420: typedef struct UnlockNotification UnlockNotification;
421: struct UnlockNotification {
422: int fired; /* True after unlock event has occurred */
423: pthread_cond_t cond; /* Condition variable to wait on */
424: pthread_mutex_t mutex; /* Mutex to protect structure */
425: };
426:
427: /*
428: ** This function is an unlock-notify callback registered with SQLite.
429: */
430: static void unlock_notify_cb(void **apArg, int nArg){
431: int i;
432: for(i=0; i<nArg; i++){
433: UnlockNotification *p = (UnlockNotification *)apArg[i];
434: pthread_mutex_lock(&p->mutex);
435: p->fired = 1;
436: pthread_cond_signal(&p->cond);
437: pthread_mutex_unlock(&p->mutex);
438: }
439: }
440:
441: /*
442: ** This function assumes that an SQLite API call (either sqlite3_prepare_v2()
443: ** or sqlite3_step()) has just returned SQLITE_LOCKED. The argument is the
444: ** associated database connection.
445: **
446: ** This function calls sqlite3_unlock_notify() to register for an
447: ** unlock-notify callback, then blocks until that callback is delivered
448: ** and returns SQLITE_OK. The caller should then retry the failed operation.
449: **
450: ** Or, if sqlite3_unlock_notify() indicates that to block would deadlock
451: ** the system, then this function returns SQLITE_LOCKED immediately. In
452: ** this case the caller should not retry the operation and should roll
453: ** back the current transaction (if any).
454: */
455: static int wait_for_unlock_notify(sqlite3 *db){
456: int rc;
457: UnlockNotification un;
458:
459: /* Initialize the UnlockNotification structure. */
460: un.fired = 0;
461: pthread_mutex_init(&un.mutex, 0);
462: pthread_cond_init(&un.cond, 0);
463:
464: /* Register for an unlock-notify callback. */
465: rc = sqlite3_unlock_notify(db, unlock_notify_cb, (void *)&un);
466: assert( rc==SQLITE_LOCKED || rc==SQLITE_OK );
467:
468: /* The call to sqlite3_unlock_notify() always returns either SQLITE_LOCKED
469: ** or SQLITE_OK.
470: **
471: ** If SQLITE_LOCKED was returned, then the system is deadlocked. In this
472: ** case this function needs to return SQLITE_LOCKED to the caller so
473: ** that the current transaction can be rolled back. Otherwise, block
474: ** until the unlock-notify callback is invoked, then return SQLITE_OK.
475: */
476: if( rc==SQLITE_OK ){
477: pthread_mutex_lock(&un.mutex);
478: if( !un.fired ){
479: pthread_cond_wait(&un.cond, &un.mutex);
480: }
481: pthread_mutex_unlock(&un.mutex);
482: }
483:
484: /* Destroy the mutex and condition variables. */
485: pthread_cond_destroy(&un.cond);
486: pthread_mutex_destroy(&un.mutex);
487:
488: return rc;
489: }
490:
491: /*
492: ** This function is a wrapper around the SQLite function sqlite3_step().
493: ** It functions in the same way as step(), except that if a required
494: ** shared-cache lock cannot be obtained, this function may block waiting for
495: ** the lock to become available. In this scenario the normal API step()
496: ** function always returns SQLITE_LOCKED.
497: **
498: ** If this function returns SQLITE_LOCKED, the caller should rollback
499: ** the current transaction (if any) and try again later. Otherwise, the
500: ** system may become deadlocked.
501: */
502: int sqlite3_blocking_step(sqlite3_stmt *pStmt){
503: int rc;
504: while( SQLITE_LOCKED==(rc = sqlite3_step(pStmt)) ){
505: rc = wait_for_unlock_notify(sqlite3_db_handle(pStmt));
506: if( rc!=SQLITE_OK ) break;
507: sqlite3_reset(pStmt);
508: }
509: return rc;
510: }
511:
512: /*
513: ** This function is a wrapper around the SQLite function sqlite3_prepare_v2().
514: ** It functions in the same way as prepare_v2(), except that if a required
515: ** shared-cache lock cannot be obtained, this function may block waiting for
516: ** the lock to become available. In this scenario the normal API prepare_v2()
517: ** function always returns SQLITE_LOCKED.
518: **
519: ** If this function returns SQLITE_LOCKED, the caller should rollback
520: ** the current transaction (if any) and try again later. Otherwise, the
521: ** system may become deadlocked.
522: */
523: int sqlite3_blocking_prepare_v2(
524: sqlite3 *db, /* Database handle. */
525: const char *zSql, /* UTF-8 encoded SQL statement. */
526: int nSql, /* Length of zSql in bytes. */
527: sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
528: const char **pz /* OUT: End of parsed string */
529: ){
530: int rc;
531: while( SQLITE_LOCKED==(rc = sqlite3_prepare_v2(db, zSql, nSql, ppStmt, pz)) ){
532: rc = wait_for_unlock_notify(db);
533: if( rc!=SQLITE_OK ) break;
534: }
535: return rc;
536: }
537: /* END_SQLITE_BLOCKING_STEP */
538:
539: /*
540: ** Usage: sqlite3_blocking_step STMT
541: **
542: ** Advance the statement to the next row.
543: */
544: static int blocking_step_proc(
545: void * clientData,
546: Tcl_Interp *interp,
547: int objc,
548: Tcl_Obj *CONST objv[]
549: ){
550:
551: sqlite3_stmt *pStmt;
552: int rc;
553:
554: if( objc!=2 ){
555: Tcl_WrongNumArgs(interp, 1, objv, "STMT");
556: return TCL_ERROR;
557: }
558:
559: pStmt = (sqlite3_stmt*)sqlite3TestTextToPtr(Tcl_GetString(objv[1]));
560: rc = sqlite3_blocking_step(pStmt);
561:
562: Tcl_SetResult(interp, (char *)sqlite3TestErrorName(rc), 0);
563: return TCL_OK;
564: }
565:
566: /*
567: ** Usage: sqlite3_blocking_prepare_v2 DB sql bytes ?tailvar?
568: ** Usage: sqlite3_nonblocking_prepare_v2 DB sql bytes ?tailvar?
569: */
570: static int blocking_prepare_v2_proc(
571: void * clientData,
572: Tcl_Interp *interp,
573: int objc,
574: Tcl_Obj *CONST objv[]
575: ){
576: sqlite3 *db;
577: const char *zSql;
578: int bytes;
579: const char *zTail = 0;
580: sqlite3_stmt *pStmt = 0;
581: char zBuf[50];
582: int rc;
583: int isBlocking = !(clientData==0);
584:
585: if( objc!=5 && objc!=4 ){
586: Tcl_AppendResult(interp, "wrong # args: should be \"",
587: Tcl_GetString(objv[0]), " DB sql bytes tailvar", 0);
588: return TCL_ERROR;
589: }
590: if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
591: zSql = Tcl_GetString(objv[2]);
592: if( Tcl_GetIntFromObj(interp, objv[3], &bytes) ) return TCL_ERROR;
593:
594: if( isBlocking ){
595: rc = sqlite3_blocking_prepare_v2(db, zSql, bytes, &pStmt, &zTail);
596: }else{
597: rc = sqlite3_prepare_v2(db, zSql, bytes, &pStmt, &zTail);
598: }
599:
600: assert(rc==SQLITE_OK || pStmt==0);
601: if( zTail && objc>=5 ){
602: if( bytes>=0 ){
603: bytes = bytes - (zTail-zSql);
604: }
605: Tcl_ObjSetVar2(interp, objv[4], 0, Tcl_NewStringObj(zTail, bytes), 0);
606: }
607: if( rc!=SQLITE_OK ){
608: assert( pStmt==0 );
609: sprintf(zBuf, "%s ", (char *)sqlite3TestErrorName(rc));
610: Tcl_AppendResult(interp, zBuf, sqlite3_errmsg(db), 0);
611: return TCL_ERROR;
612: }
613:
614: if( pStmt ){
615: if( sqlite3TestMakePointerStr(interp, zBuf, pStmt) ) return TCL_ERROR;
616: Tcl_AppendResult(interp, zBuf, 0);
617: }
618: return TCL_OK;
619: }
620:
621: #endif /* SQLITE_OS_UNIX && SQLITE_ENABLE_UNLOCK_NOTIFY */
622: /*
623: ** End of implementation of [sqlite3_blocking_step].
624: ************************************************************************/
625:
626: /*
627: ** Register commands with the TCL interpreter.
628: */
629: int SqlitetestThread_Init(Tcl_Interp *interp){
630: Tcl_CreateObjCommand(interp, "sqlthread", sqlthread_proc, 0, 0);
631: Tcl_CreateObjCommand(interp, "clock_seconds", clock_seconds_proc, 0, 0);
632: #if SQLITE_OS_UNIX && defined(SQLITE_ENABLE_UNLOCK_NOTIFY)
633: Tcl_CreateObjCommand(interp, "sqlite3_blocking_step", blocking_step_proc,0,0);
634: Tcl_CreateObjCommand(interp,
635: "sqlite3_blocking_prepare_v2", blocking_prepare_v2_proc, (void *)1, 0);
636: Tcl_CreateObjCommand(interp,
637: "sqlite3_nonblocking_prepare_v2", blocking_prepare_v2_proc, 0, 0);
638: #endif
639: return TCL_OK;
640: }
641: #else
642: int SqlitetestThread_Init(Tcl_Interp *interp){
643: return TCL_OK;
644: }
645: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to test_thread.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src