OLD | NEW |
| (Empty) |
1 /* | |
2 ** 2005 December 14 | |
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 a binding of the asynchronous IO extension interface | |
14 ** (defined in ext/async/sqlite3async.h) to Tcl. | |
15 */ | |
16 | |
17 #define TCL_THREADS | |
18 #include <tcl.h> | |
19 | |
20 #ifdef SQLITE_ENABLE_ASYNCIO | |
21 | |
22 #include "sqlite3async.h" | |
23 #include "sqlite3.h" | |
24 #include <assert.h> | |
25 | |
26 /* From main.c */ | |
27 extern const char *sqlite3ErrName(int); | |
28 | |
29 | |
30 struct TestAsyncGlobal { | |
31 int isInstalled; /* True when async VFS is installed */ | |
32 } testasync_g = { 0 }; | |
33 | |
34 TCL_DECLARE_MUTEX(testasync_g_writerMutex); | |
35 | |
36 /* | |
37 ** sqlite3async_initialize PARENT-VFS ISDEFAULT | |
38 */ | |
39 static int testAsyncInit( | |
40 void * clientData, | |
41 Tcl_Interp *interp, | |
42 int objc, | |
43 Tcl_Obj *CONST objv[] | |
44 ){ | |
45 const char *zParent; | |
46 int isDefault; | |
47 int rc; | |
48 | |
49 if( objc!=3 ){ | |
50 Tcl_WrongNumArgs(interp, 1, objv, "PARENT-VFS ISDEFAULT"); | |
51 return TCL_ERROR; | |
52 } | |
53 zParent = Tcl_GetString(objv[1]); | |
54 if( !*zParent ) { | |
55 zParent = 0; | |
56 } | |
57 if( Tcl_GetBooleanFromObj(interp, objv[2], &isDefault) ){ | |
58 return TCL_ERROR; | |
59 } | |
60 | |
61 rc = sqlite3async_initialize(zParent, isDefault); | |
62 if( rc!=SQLITE_OK ){ | |
63 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1)); | |
64 return TCL_ERROR; | |
65 } | |
66 return TCL_OK; | |
67 } | |
68 | |
69 /* | |
70 ** sqlite3async_shutdown | |
71 */ | |
72 static int testAsyncShutdown( | |
73 void * clientData, | |
74 Tcl_Interp *interp, | |
75 int objc, | |
76 Tcl_Obj *CONST objv[] | |
77 ){ | |
78 sqlite3async_shutdown(); | |
79 return TCL_OK; | |
80 } | |
81 | |
82 static Tcl_ThreadCreateType tclWriterThread(ClientData pIsStarted){ | |
83 Tcl_MutexLock(&testasync_g_writerMutex); | |
84 *((int *)pIsStarted) = 1; | |
85 sqlite3async_run(); | |
86 Tcl_MutexUnlock(&testasync_g_writerMutex); | |
87 Tcl_ExitThread(0); | |
88 TCL_THREAD_CREATE_RETURN; | |
89 } | |
90 | |
91 /* | |
92 ** sqlite3async_start | |
93 ** | |
94 ** Start a new writer thread. | |
95 */ | |
96 static int testAsyncStart( | |
97 void * clientData, | |
98 Tcl_Interp *interp, | |
99 int objc, | |
100 Tcl_Obj *CONST objv[] | |
101 ){ | |
102 volatile int isStarted = 0; | |
103 ClientData threadData = (ClientData)&isStarted; | |
104 | |
105 Tcl_ThreadId x; | |
106 const int nStack = TCL_THREAD_STACK_DEFAULT; | |
107 const int flags = TCL_THREAD_NOFLAGS; | |
108 int rc; | |
109 | |
110 rc = Tcl_CreateThread(&x, tclWriterThread, threadData, nStack, flags); | |
111 if( rc!=TCL_OK ){ | |
112 Tcl_AppendResult(interp, "Tcl_CreateThread() failed", 0); | |
113 return TCL_ERROR; | |
114 } | |
115 | |
116 while( isStarted==0 ) { /* Busy loop */ } | |
117 return TCL_OK; | |
118 } | |
119 | |
120 /* | |
121 ** sqlite3async_wait | |
122 ** | |
123 ** Wait for the current writer thread to terminate. | |
124 ** | |
125 ** If the current writer thread is set to run forever then this | |
126 ** command would block forever. To prevent that, an error is returned. | |
127 */ | |
128 static int testAsyncWait( | |
129 void * clientData, | |
130 Tcl_Interp *interp, | |
131 int objc, | |
132 Tcl_Obj *CONST objv[] | |
133 ){ | |
134 int eCond; | |
135 if( objc!=1 ){ | |
136 Tcl_WrongNumArgs(interp, 1, objv, ""); | |
137 return TCL_ERROR; | |
138 } | |
139 | |
140 sqlite3async_control(SQLITEASYNC_GET_HALT, &eCond); | |
141 if( eCond==SQLITEASYNC_HALT_NEVER ){ | |
142 Tcl_AppendResult(interp, "would block forever", (char*)0); | |
143 return TCL_ERROR; | |
144 } | |
145 | |
146 Tcl_MutexLock(&testasync_g_writerMutex); | |
147 Tcl_MutexUnlock(&testasync_g_writerMutex); | |
148 return TCL_OK; | |
149 } | |
150 | |
151 /* | |
152 ** sqlite3async_control OPTION ?VALUE? | |
153 */ | |
154 static int testAsyncControl( | |
155 void * clientData, | |
156 Tcl_Interp *interp, | |
157 int objc, | |
158 Tcl_Obj *CONST objv[] | |
159 ){ | |
160 int rc = SQLITE_OK; | |
161 int aeOpt[] = { SQLITEASYNC_HALT, SQLITEASYNC_DELAY, SQLITEASYNC_LOCKFILES }; | |
162 const char *azOpt[] = { "halt", "delay", "lockfiles", 0 }; | |
163 const char *az[] = { "never", "now", "idle", 0 }; | |
164 int iVal; | |
165 int eOpt; | |
166 | |
167 if( objc!=2 && objc!=3 ){ | |
168 Tcl_WrongNumArgs(interp, 1, objv, "OPTION ?VALUE?"); | |
169 return TCL_ERROR; | |
170 } | |
171 if( Tcl_GetIndexFromObj(interp, objv[1], azOpt, "option", 0, &eOpt) ){ | |
172 return TCL_ERROR; | |
173 } | |
174 eOpt = aeOpt[eOpt]; | |
175 | |
176 if( objc==3 ){ | |
177 switch( eOpt ){ | |
178 case SQLITEASYNC_HALT: { | |
179 assert( SQLITEASYNC_HALT_NEVER==0 ); | |
180 assert( SQLITEASYNC_HALT_NOW==1 ); | |
181 assert( SQLITEASYNC_HALT_IDLE==2 ); | |
182 if( Tcl_GetIndexFromObj(interp, objv[2], az, "value", 0, &iVal) ){ | |
183 return TCL_ERROR; | |
184 } | |
185 break; | |
186 } | |
187 case SQLITEASYNC_DELAY: | |
188 if( Tcl_GetIntFromObj(interp, objv[2], &iVal) ){ | |
189 return TCL_ERROR; | |
190 } | |
191 break; | |
192 | |
193 case SQLITEASYNC_LOCKFILES: | |
194 if( Tcl_GetBooleanFromObj(interp, objv[2], &iVal) ){ | |
195 return TCL_ERROR; | |
196 } | |
197 break; | |
198 } | |
199 | |
200 rc = sqlite3async_control(eOpt, iVal); | |
201 } | |
202 | |
203 if( rc==SQLITE_OK ){ | |
204 rc = sqlite3async_control( | |
205 eOpt==SQLITEASYNC_HALT ? SQLITEASYNC_GET_HALT : | |
206 eOpt==SQLITEASYNC_DELAY ? SQLITEASYNC_GET_DELAY : | |
207 SQLITEASYNC_GET_LOCKFILES, &iVal); | |
208 } | |
209 | |
210 if( rc!=SQLITE_OK ){ | |
211 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1)); | |
212 return TCL_ERROR; | |
213 } | |
214 | |
215 if( eOpt==SQLITEASYNC_HALT ){ | |
216 Tcl_SetObjResult(interp, Tcl_NewStringObj(az[iVal], -1)); | |
217 }else{ | |
218 Tcl_SetObjResult(interp, Tcl_NewIntObj(iVal)); | |
219 } | |
220 | |
221 return TCL_OK; | |
222 } | |
223 | |
224 #endif /* SQLITE_ENABLE_ASYNCIO */ | |
225 | |
226 /* | |
227 ** This routine registers the custom TCL commands defined in this | |
228 ** module. This should be the only procedure visible from outside | |
229 ** of this module. | |
230 */ | |
231 int Sqlitetestasync_Init(Tcl_Interp *interp){ | |
232 #ifdef SQLITE_ENABLE_ASYNCIO | |
233 Tcl_CreateObjCommand(interp,"sqlite3async_start",testAsyncStart,0,0); | |
234 Tcl_CreateObjCommand(interp,"sqlite3async_wait",testAsyncWait,0,0); | |
235 | |
236 Tcl_CreateObjCommand(interp,"sqlite3async_control",testAsyncControl,0,0); | |
237 Tcl_CreateObjCommand(interp,"sqlite3async_initialize",testAsyncInit,0,0); | |
238 Tcl_CreateObjCommand(interp,"sqlite3async_shutdown",testAsyncShutdown,0,0); | |
239 #endif /* SQLITE_ENABLE_ASYNCIO */ | |
240 return TCL_OK; | |
241 } | |
OLD | NEW |