third_party/sqlite/sqlite-src-3080704/src/tclsqlite.c - Issue 2363173002: [sqlite] Remove obsolete reference version 3.8.7.4.

Side by Side Diff: third_party/sqlite/sqlite-src-3080704/src/tclsqlite.c

Issue 2363173002: [sqlite] Remove obsolete reference version 3.8.7.4. (Closed)

Patch Set: Created 4 years, 3 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

OLD	NEW
	(Empty)
1 /*

2 ** 2001 September 15

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 ** A TCL Interface to SQLite. Append this file to sqlite3.c and

13 ** compile the whole thing to build a TCL-enabled version of SQLite.

14 **

15 ** Compile-time options:

16 **

17 ** -DTCLSH=1 Add a "main()" routine that works as a tclsh.

18 **

19 ** -DSQLITE_TCLMD5 When used in conjuction with -DTCLSH=1, add

20 ** four new commands to the TCL interpreter for

21 ** generating MD5 checksums: md5, md5file,

22 ** md5-10x8, and md5file-10x8.

23 **

24 ** -DSQLITE_TEST When used in conjuction with -DTCLSH=1, add

25 ** hundreds of new commands used for testing

26 ** SQLite. This option implies -DSQLITE_TCLMD5.

27 */

28 #include "tcl.h"

29 #include <errno.h>

30

31 /*

32 ** Some additional include files are needed if this file is not

33 ** appended to the amalgamation.

34 */

35 #ifndef SQLITE_AMALGAMATION

36 # include "sqlite3.h"

37 # include <stdlib.h>

38 # include <string.h>

39 # include <assert.h>

40 typedef unsigned char u8;

41 #endif

42 #include <ctype.h>

43

44 /* Used to get the current process ID */

45 #if !defined(_WIN32)

46 # include <unistd.h>

47 # define GETPID getpid

48 #elif !defined(_WIN32_WCE)

49 # ifndef SQLITE_AMALGAMATION

50 # define WIN32_LEAN_AND_MEAN

51 # include <windows.h>

52 # endif

53 # define GETPID (int)GetCurrentProcessId

54 #endif

55

56 /*

57 * Windows needs to know which symbols to export. Unix does not.

58 * BUILD_sqlite should be undefined for Unix.

59 */

60 #ifdef BUILD_sqlite

61 #undef TCL_STORAGE_CLASS

62 #define TCL_STORAGE_CLASS DLLEXPORT

63 #endif /* BUILD_sqlite */

64

65 #define NUM_PREPARED_STMTS 10

66 #define MAX_PREPARED_STMTS 100

67

68 /* Forward declaration */

69 typedef struct SqliteDb SqliteDb;

70

71 /*

72 ** New SQL functions can be created as TCL scripts. Each such function

73 ** is described by an instance of the following structure.

74 */

75 typedef struct SqlFunc SqlFunc;

76 struct SqlFunc {

77 Tcl_Interp interp; / The TCL interpret to execute the function */

78 Tcl_Obj pScript; / The Tcl_Obj representation of the script */

79 SqliteDb pDb; / Database connection that owns this function */

80 int useEvalObjv; /* True if it is safe to use Tcl_EvalObjv */

81 char zName; / Name of this function */

82 SqlFunc pNext; / Next function on the list of them all */

83 };

84

85 /*

86 ** New collation sequences function can be created as TCL scripts. Each such

87 ** function is described by an instance of the following structure.

88 */

89 typedef struct SqlCollate SqlCollate;

90 struct SqlCollate {

91 Tcl_Interp interp; / The TCL interpret to execute the function */

92 char zScript; / The script to be run */

93 SqlCollate pNext; / Next function on the list of them all */

94 };

95

96 /*

97 ** Prepared statements are cached for faster execution. Each prepared

98 ** statement is described by an instance of the following structure.

99 */

100 typedef struct SqlPreparedStmt SqlPreparedStmt;

101 struct SqlPreparedStmt {

102 SqlPreparedStmt pNext; / Next in linked list */

103 SqlPreparedStmt pPrev; / Previous on the list */

104 sqlite3_stmt pStmt; / The prepared statement */

105 int nSql; /* chars in zSql[] */

106 const char zSql; / Text of the SQL statement */

107 int nParm; /* Size of apParm array */

108 Tcl_Obj *apParm; / Array of referenced object pointers */

109 };

110

111 typedef struct IncrblobChannel IncrblobChannel;

112

113 /*

114 ** There is one instance of this structure for each SQLite database

115 ** that has been opened by the SQLite TCL interface.

116 **

117 ** If this module is built with SQLITE_TEST defined (to create the SQLite

118 ** testfixture executable), then it may be configured to use either

119 ** sqlite3_prepare_v2() or sqlite3_prepare() to prepare SQL statements.

120 ** If SqliteDb.bLegacyPrepare is true, sqlite3_prepare() is used.

121 */

122 struct SqliteDb {

123 sqlite3 db; / The "real" database structure. MUST BE FIRST */

124 Tcl_Interp interp; / The interpreter used for this database */

125 char zBusy; / The busy callback routine */

126 char zCommit; / The commit hook callback routine */

127 char zTrace; / The trace callback routine */

128 char zProfile; / The profile callback routine */

129 char zProgress; / The progress callback routine */

130 char zAuth; / The authorization callback routine */

131 int disableAuth; /* Disable the authorizer if it exists */

132 char zNull; / Text to substitute for an SQL NULL value */

133 SqlFunc pFunc; / List of SQL functions */

134 Tcl_Obj pUpdateHook; / Update hook script (if any) */

135 Tcl_Obj pRollbackHook; / Rollback hook script (if any) */

136 Tcl_Obj pWalHook; / WAL hook script (if any) */

137 Tcl_Obj pUnlockNotify; / Unlock notify script (if any) */

138 SqlCollate pCollate; / List of SQL collation functions */

139 int rc; /* Return code of most recent sqlite3_exec() */

140 Tcl_Obj pCollateNeeded; / Collation needed script */

141 SqlPreparedStmt stmtList; / List of prepared statements*/

142 SqlPreparedStmt stmtLast; / Last statement in the list */

143 int maxStmt; /* The next maximum number of stmtList */

144 int nStmt; /* Number of statements in stmtList */

145 IncrblobChannel pIncrblob;/ Linked list of open incrblob channels */

146 int nStep, nSort, nIndex; /* Statistics for most recent operation */

147 int nTransaction; /* Number of nested [transaction] methods */

148 #ifdef SQLITE_TEST

149 int bLegacyPrepare; /* True to use sqlite3_prepare() */

150 #endif

151 };

152

153 struct IncrblobChannel {

154 sqlite3_blob pBlob; / sqlite3 blob handle */

155 SqliteDb pDb; / Associated database connection */

156 int iSeek; /* Current seek offset */

157 Tcl_Channel channel; /* Channel identifier */

158 IncrblobChannel pNext; / Linked list of all open incrblob channels */

159 IncrblobChannel pPrev; / Linked list of all open incrblob channels */

160 };

161

162 /*

163 ** Compute a string length that is limited to what can be stored in

164 ** lower 30 bits of a 32-bit signed integer.

165 */

166 static int strlen30(const char *z){

167 const char *z2 = z;

168 while( *z2 ){ z2++; }

169 return 0x3fffffff & (int)(z2 - z);

170 }

171

172

173 #ifndef SQLITE_OMIT_INCRBLOB

174 /*

175 ** Close all incrblob channels opened using database connection pDb.

176 ** This is called when shutting down the database connection.

177 */

178 static void closeIncrblobChannels(SqliteDb *pDb){

179 IncrblobChannel *p;

180 IncrblobChannel *pNext;

181

182 for(p=pDb->pIncrblob; p; p=pNext){

183 pNext = p->pNext;

184

185 /* Note: Calling unregister here call Tcl_Close on the incrblob channel,

186 ** which deletes the IncrblobChannel structure at *p. So do not

187 ** call Tcl_Free() here.

188 */

189 Tcl_UnregisterChannel(pDb->interp, p->channel);

190 }

191 }

192

193 /*

194 ** Close an incremental blob channel.

195 */

196 static int incrblobClose(ClientData instanceData, Tcl_Interp *interp){

197 IncrblobChannel p = (IncrblobChannel )instanceData;

198 int rc = sqlite3_blob_close(p->pBlob);

199 sqlite3 *db = p->pDb->db;

200

201 /* Remove the channel from the SqliteDb.pIncrblob list. */

202 if( p->pNext ){

203 p->pNext->pPrev = p->pPrev;

204 }

205 if( p->pPrev ){

206 p->pPrev->pNext = p->pNext;

207 }

208 if( p->pDb->pIncrblob==p ){

209 p->pDb->pIncrblob = p->pNext;

210 }

211

212 /* Free the IncrblobChannel structure */

213 Tcl_Free((char *)p);

214

215 if( rc!=SQLITE_OK ){

216 Tcl_SetResult(interp, (char *)sqlite3_errmsg(db), TCL_VOLATILE);

217 return TCL_ERROR;

218 }

219 return TCL_OK;

220 }

221

222 /*

223 ** Read data from an incremental blob channel.

224 */

225 static int incrblobInput(

226 ClientData instanceData,

227 char *buf,

228 int bufSize,

229 int *errorCodePtr

230 ){

231 IncrblobChannel p = (IncrblobChannel )instanceData;

232 int nRead = bufSize; /* Number of bytes to read */

233 int nBlob; /* Total size of the blob */

234 int rc; /* sqlite error code */

235

236 nBlob = sqlite3_blob_bytes(p->pBlob);

237 if( (p->iSeek+nRead)>nBlob ){

238 nRead = nBlob-p->iSeek;

239 }

240 if( nRead<=0 ){

241 return 0;

242 }

243

244 rc = sqlite3_blob_read(p->pBlob, (void *)buf, nRead, p->iSeek);

245 if( rc!=SQLITE_OK ){

246 *errorCodePtr = rc;

247 return -1;

248 }

249

250 p->iSeek += nRead;

251 return nRead;

252 }

253

254 /*

255 ** Write data to an incremental blob channel.

256 */

257 static int incrblobOutput(

258 ClientData instanceData,

259 CONST char *buf,

260 int toWrite,

261 int *errorCodePtr

262 ){

263 IncrblobChannel p = (IncrblobChannel )instanceData;

264 int nWrite = toWrite; /* Number of bytes to write */

265 int nBlob; /* Total size of the blob */

266 int rc; /* sqlite error code */

267

268 nBlob = sqlite3_blob_bytes(p->pBlob);

269 if( (p->iSeek+nWrite)>nBlob ){

270 *errorCodePtr = EINVAL;

271 return -1;

272 }

273 if( nWrite<=0 ){

274 return 0;

275 }

276

277 rc = sqlite3_blob_write(p->pBlob, (void *)buf, nWrite, p->iSeek);

278 if( rc!=SQLITE_OK ){

279 *errorCodePtr = EIO;

280 return -1;

281 }

282

283 p->iSeek += nWrite;

284 return nWrite;

285 }

286

287 /*

288 ** Seek an incremental blob channel.

289 */

290 static int incrblobSeek(

291 ClientData instanceData,

292 long offset,

293 int seekMode,

294 int *errorCodePtr

295 ){

296 IncrblobChannel p = (IncrblobChannel )instanceData;

297

298 switch( seekMode ){

299 case SEEK_SET:

300 p->iSeek = offset;

301 break;

302 case SEEK_CUR:

303 p->iSeek += offset;

304 break;

305 case SEEK_END:

306 p->iSeek = sqlite3_blob_bytes(p->pBlob) + offset;

307 break;

308

309 default: assert(!"Bad seekMode");

310 }

311

312 return p->iSeek;

313 }

314

315

316 static void incrblobWatch(ClientData instanceData, int mode){

317 /* NO-OP */

318 }

319 static int incrblobHandle(ClientData instanceData, int dir, ClientData *hPtr){

320 return TCL_ERROR;

321 }

322

323 static Tcl_ChannelType IncrblobChannelType = {

324 "incrblob", /* typeName */

325 TCL_CHANNEL_VERSION_2, /* version */

326 incrblobClose, /* closeProc */

327 incrblobInput, /* inputProc */

328 incrblobOutput, /* outputProc */

329 incrblobSeek, /* seekProc */

330 0, /* setOptionProc */

331 0, /* getOptionProc */

332 incrblobWatch, /* watchProc (this is a no-op) */

333 incrblobHandle, /* getHandleProc (always returns error) */

334 0, /* close2Proc */

335 0, /* blockModeProc */

336 0, /* flushProc */

337 0, /* handlerProc */

338 0, /* wideSeekProc */

339 };

340

341 /*

342 ** Create a new incrblob channel.

343 */

344 static int createIncrblobChannel(

345 Tcl_Interp *interp,

346 SqliteDb *pDb,

347 const char *zDb,

348 const char *zTable,

349 const char *zColumn,

350 sqlite_int64 iRow,

351 int isReadonly

352 ){

353 IncrblobChannel *p;

354 sqlite3 *db = pDb->db;

355 sqlite3_blob *pBlob;

356 int rc;

357 int flags = TCL_READABLE\|(isReadonly ? 0 : TCL_WRITABLE);

358

359 /* This variable is used to name the channels: "incrblob_[incr count]" */

360 static int count = 0;

361 char zChannel[64];

362

363 rc = sqlite3_blob_open(db, zDb, zTable, zColumn, iRow, !isReadonly, &pBlob);

364 if( rc!=SQLITE_OK ){

365 Tcl_SetResult(interp, (char *)sqlite3_errmsg(pDb->db), TCL_VOLATILE);

366 return TCL_ERROR;

367 }

368

369 p = (IncrblobChannel *)Tcl_Alloc(sizeof(IncrblobChannel));

370 p->iSeek = 0;

371 p->pBlob = pBlob;

372

373 sqlite3_snprintf(sizeof(zChannel), zChannel, "incrblob_%d", ++count);

374 p->channel = Tcl_CreateChannel(&IncrblobChannelType, zChannel, p, flags);

375 Tcl_RegisterChannel(interp, p->channel);

376

377 /* Link the new channel into the SqliteDb.pIncrblob list. */

378 p->pNext = pDb->pIncrblob;

379 p->pPrev = 0;

380 if( p->pNext ){

381 p->pNext->pPrev = p;

382 }

383 pDb->pIncrblob = p;

384 p->pDb = pDb;

385

386 Tcl_SetResult(interp, (char *)Tcl_GetChannelName(p->channel), TCL_VOLATILE);

387 return TCL_OK;

388 }

389 #else /* else clause for "#ifndef SQLITE_OMIT_INCRBLOB" */

390 #define closeIncrblobChannels(pDb)

391 #endif

392

393 /*

394 ** Look at the script prefix in pCmd. We will be executing this script

395 ** after first appending one or more arguments. This routine analyzes

396 ** the script to see if it is safe to use Tcl_EvalObjv() on the script

397 ** rather than the more general Tcl_EvalEx(). Tcl_EvalObjv() is much

398 ** faster.

399 **

400 ** Scripts that are safe to use with Tcl_EvalObjv() consists of a

401 ** command name followed by zero or more arguments with no [...] or $

402 ** or {...} or ; to be seen anywhere. Most callback scripts consist

403 ** of just a single procedure name and they meet this requirement.

404 */

405 static int safeToUseEvalObjv(Tcl_Interp interp, Tcl_Obj pCmd){

406 /* We could try to do something with Tcl_Parse(). But we will instead

407 ** just do a search for forbidden characters. If any of the forbidden

408 ** characters appear in pCmd, we will report the string as unsafe.

409 */

410 const char *z;

411 int n;

412 z = Tcl_GetStringFromObj(pCmd, &n);

413 while( n-- > 0 ){

414 int c = *(z++);

415 if( c=='$' \|\| c=='[' \|\| c==';' ) return 0;

416 }

417 return 1;

418 }

419

420 /*

421 ** Find an SqlFunc structure with the given name. Or create a new

422 ** one if an existing one cannot be found. Return a pointer to the

423 ** structure.

424 */

425 static SqlFunc findSqlFunc(SqliteDb pDb, const char *zName){

426 SqlFunc p, pNew;

427 int nName = strlen30(zName);

428 pNew = (SqlFunc)Tcl_Alloc( sizeof(pNew) + nName + 1 );

429 pNew->zName = (char*)&pNew[1];

430 memcpy(pNew->zName, zName, nName+1);

431 for(p=pDb->pFunc; p; p=p->pNext){

432 if( sqlite3_stricmp(p->zName, pNew->zName)==0 ){

433 Tcl_Free((char*)pNew);

434 return p;

435 }

436 }

437 pNew->interp = pDb->interp;

438 pNew->pDb = pDb;

439 pNew->pScript = 0;

440 pNew->pNext = pDb->pFunc;

441 pDb->pFunc = pNew;

442 return pNew;

443 }

444

445 /*

446 ** Free a single SqlPreparedStmt object.

447 */

448 static void dbFreeStmt(SqlPreparedStmt *pStmt){

449 #ifdef SQLITE_TEST

450 if( sqlite3_sql(pStmt->pStmt)==0 ){

451 Tcl_Free((char *)pStmt->zSql);

452 }

453 #endif

454 sqlite3_finalize(pStmt->pStmt);

455 Tcl_Free((char *)pStmt);

456 }

457

458 /*

459 ** Finalize and free a list of prepared statements

460 */

461 static void flushStmtCache(SqliteDb *pDb){

462 SqlPreparedStmt *pPreStmt;

463 SqlPreparedStmt *pNext;

464

465 for(pPreStmt = pDb->stmtList; pPreStmt; pPreStmt=pNext){

466 pNext = pPreStmt->pNext;

467 dbFreeStmt(pPreStmt);

468 }

469 pDb->nStmt = 0;

470 pDb->stmtLast = 0;

471 pDb->stmtList = 0;

472 }

473

474 /*

475 ** TCL calls this procedure when an sqlite3 database command is

476 ** deleted.

477 */

478 static void DbDeleteCmd(void *db){

479 SqliteDb pDb = (SqliteDb)db;

480 flushStmtCache(pDb);

481 closeIncrblobChannels(pDb);

482 sqlite3_close(pDb->db);

483 while( pDb->pFunc ){

484 SqlFunc *pFunc = pDb->pFunc;

485 pDb->pFunc = pFunc->pNext;

486 assert( pFunc->pDb==pDb );

487 Tcl_DecrRefCount(pFunc->pScript);

488 Tcl_Free((char*)pFunc);

489 }

490 while( pDb->pCollate ){

491 SqlCollate *pCollate = pDb->pCollate;

492 pDb->pCollate = pCollate->pNext;

493 Tcl_Free((char*)pCollate);

494 }

495 if( pDb->zBusy ){

496 Tcl_Free(pDb->zBusy);

497 }

498 if( pDb->zTrace ){

499 Tcl_Free(pDb->zTrace);

500 }

501 if( pDb->zProfile ){

502 Tcl_Free(pDb->zProfile);

503 }

504 if( pDb->zAuth ){

505 Tcl_Free(pDb->zAuth);

506 }

507 if( pDb->zNull ){

508 Tcl_Free(pDb->zNull);

509 }

510 if( pDb->pUpdateHook ){

511 Tcl_DecrRefCount(pDb->pUpdateHook);

512 }

513 if( pDb->pRollbackHook ){

514 Tcl_DecrRefCount(pDb->pRollbackHook);

515 }

516 if( pDb->pWalHook ){

517 Tcl_DecrRefCount(pDb->pWalHook);

518 }

519 if( pDb->pCollateNeeded ){

520 Tcl_DecrRefCount(pDb->pCollateNeeded);

521 }

522 Tcl_Free((char*)pDb);

523 }

524

525 /*

526 ** This routine is called when a database file is locked while trying

527 ** to execute SQL.

528 */

529 static int DbBusyHandler(void *cd, int nTries){

530 SqliteDb pDb = (SqliteDb)cd;

531 int rc;

532 char zVal[30];

533

534 sqlite3_snprintf(sizeof(zVal), zVal, "%d", nTries);

535 rc = Tcl_VarEval(pDb->interp, pDb->zBusy, " ", zVal, (char*)0);

536 if( rc!=TCL_OK \|\| atoi(Tcl_GetStringResult(pDb->interp)) ){

537 return 0;

538 }

539 return 1;

540 }

541

542 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK

543 /*

544 ** This routine is invoked as the 'progress callback' for the database.

545 */

546 static int DbProgressHandler(void *cd){

547 SqliteDb pDb = (SqliteDb)cd;

548 int rc;

549

550 assert( pDb->zProgress );

551 rc = Tcl_Eval(pDb->interp, pDb->zProgress);

552 if( rc!=TCL_OK \|\| atoi(Tcl_GetStringResult(pDb->interp)) ){

553 return 1;

554 }

555 return 0;

556 }

557 #endif

558

559 #ifndef SQLITE_OMIT_TRACE

560 /*

561 ** This routine is called by the SQLite trace handler whenever a new

562 ** block of SQL is executed. The TCL script in pDb->zTrace is executed.

563 */

564 static void DbTraceHandler(void cd, const char zSql){

565 SqliteDb pDb = (SqliteDb)cd;

566 Tcl_DString str;

567

568 Tcl_DStringInit(&str);

569 Tcl_DStringAppend(&str, pDb->zTrace, -1);

570 Tcl_DStringAppendElement(&str, zSql);

571 Tcl_Eval(pDb->interp, Tcl_DStringValue(&str));

572 Tcl_DStringFree(&str);

573 Tcl_ResetResult(pDb->interp);

574 }

575 #endif

576

577 #ifndef SQLITE_OMIT_TRACE

578 /*

579 ** This routine is called by the SQLite profile handler after a statement

580 ** SQL has executed. The TCL script in pDb->zProfile is evaluated.

581 */

582 static void DbProfileHandler(void cd, const char zSql, sqlite_uint64 tm){

583 SqliteDb pDb = (SqliteDb)cd;

584 Tcl_DString str;

585 char zTm[100];

586

587 sqlite3_snprintf(sizeof(zTm)-1, zTm, "%lld", tm);

588 Tcl_DStringInit(&str);

589 Tcl_DStringAppend(&str, pDb->zProfile, -1);

590 Tcl_DStringAppendElement(&str, zSql);

591 Tcl_DStringAppendElement(&str, zTm);

592 Tcl_Eval(pDb->interp, Tcl_DStringValue(&str));

593 Tcl_DStringFree(&str);

594 Tcl_ResetResult(pDb->interp);

595 }

596 #endif

597

598 /*

599 ** This routine is called when a transaction is committed. The

600 ** TCL script in pDb->zCommit is executed. If it returns non-zero or

601 ** if it throws an exception, the transaction is rolled back instead

602 ** of being committed.

603 */

604 static int DbCommitHandler(void *cd){

605 SqliteDb pDb = (SqliteDb)cd;

606 int rc;

607

608 rc = Tcl_Eval(pDb->interp, pDb->zCommit);

609 if( rc!=TCL_OK \|\| atoi(Tcl_GetStringResult(pDb->interp)) ){

610 return 1;

611 }

612 return 0;

613 }

614

615 static void DbRollbackHandler(void *clientData){

616 SqliteDb pDb = (SqliteDb)clientData;

617 assert(pDb->pRollbackHook);

618 if( TCL_OK!=Tcl_EvalObjEx(pDb->interp, pDb->pRollbackHook, 0) ){

619 Tcl_BackgroundError(pDb->interp);

620 }

621 }

622

623 /*

624 ** This procedure handles wal_hook callbacks.

625 */

626 static int DbWalHandler(

627 void *clientData,

628 sqlite3 *db,

629 const char *zDb,

630 int nEntry

631 ){

632 int ret = SQLITE_OK;

633 Tcl_Obj *p;

634 SqliteDb pDb = (SqliteDb)clientData;

635 Tcl_Interp *interp = pDb->interp;

636 assert(pDb->pWalHook);

637

638 p = Tcl_DuplicateObj(pDb->pWalHook);

639 Tcl_IncrRefCount(p);

640 Tcl_ListObjAppendElement(interp, p, Tcl_NewStringObj(zDb, -1));

641 Tcl_ListObjAppendElement(interp, p, Tcl_NewIntObj(nEntry));

642 if( TCL_OK!=Tcl_EvalObjEx(interp, p, 0)

643 \|\| TCL_OK!=Tcl_GetIntFromObj(interp, Tcl_GetObjResult(interp), &ret)

644 ){

645 Tcl_BackgroundError(interp);

646 }

647 Tcl_DecrRefCount(p);

648

649 return ret;

650 }

651

652 #if defined(SQLITE_TEST) && defined(SQLITE_ENABLE_UNLOCK_NOTIFY)

653 static void setTestUnlockNotifyVars(Tcl_Interp *interp, int iArg, int nArg){

654 char zBuf[64];

655 sprintf(zBuf, "%d", iArg);

656 Tcl_SetVar(interp, "sqlite_unlock_notify_arg", zBuf, TCL_GLOBAL_ONLY);

657 sprintf(zBuf, "%d", nArg);

658 Tcl_SetVar(interp, "sqlite_unlock_notify_argcount", zBuf, TCL_GLOBAL_ONLY);

659 }

660 #else

661 # define setTestUnlockNotifyVars(x,y,z)

662 #endif

663

664 #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY

665 static void DbUnlockNotify(void **apArg, int nArg){

666 int i;

667 for(i=0; i<nArg; i++){

668 const int flags = (TCL_EVAL_GLOBAL\|TCL_EVAL_DIRECT);

669 SqliteDb pDb = (SqliteDb )apArg[i];

670 setTestUnlockNotifyVars(pDb->interp, i, nArg);

671 assert( pDb->pUnlockNotify);

672 Tcl_EvalObjEx(pDb->interp, pDb->pUnlockNotify, flags);

673 Tcl_DecrRefCount(pDb->pUnlockNotify);

674 pDb->pUnlockNotify = 0;

675 }

676 }

677 #endif

678

679 static void DbUpdateHandler(

680 void *p,

681 int op,

682 const char *zDb,

683 const char *zTbl,

684 sqlite_int64 rowid

685 ){

686 SqliteDb pDb = (SqliteDb )p;

687 Tcl_Obj *pCmd;

688

689 assert( pDb->pUpdateHook );

690 assert( op==SQLITE_INSERT \|\| op==SQLITE_UPDATE \|\| op==SQLITE_DELETE );

691

692 pCmd = Tcl_DuplicateObj(pDb->pUpdateHook);

693 Tcl_IncrRefCount(pCmd);

694 Tcl_ListObjAppendElement(0, pCmd, Tcl_NewStringObj(

695 ( (op==SQLITE_INSERT)?"INSERT":(op==SQLITE_UPDATE)?"UPDATE":"DELETE"), -1));

696 Tcl_ListObjAppendElement(0, pCmd, Tcl_NewStringObj(zDb, -1));

697 Tcl_ListObjAppendElement(0, pCmd, Tcl_NewStringObj(zTbl, -1));

698 Tcl_ListObjAppendElement(0, pCmd, Tcl_NewWideIntObj(rowid));

699 Tcl_EvalObjEx(pDb->interp, pCmd, TCL_EVAL_DIRECT);

700 Tcl_DecrRefCount(pCmd);

701 }

702

703 static void tclCollateNeeded(

704 void *pCtx,

705 sqlite3 *db,

706 int enc,

707 const char *zName

708 ){

709 SqliteDb pDb = (SqliteDb )pCtx;

710 Tcl_Obj *pScript = Tcl_DuplicateObj(pDb->pCollateNeeded);

711 Tcl_IncrRefCount(pScript);

712 Tcl_ListObjAppendElement(0, pScript, Tcl_NewStringObj(zName, -1));

713 Tcl_EvalObjEx(pDb->interp, pScript, 0);

714 Tcl_DecrRefCount(pScript);

715 }

716

717 /*

718 ** This routine is called to evaluate an SQL collation function implemented

719 ** using TCL script.

720 */

721 static int tclSqlCollate(

722 void *pCtx,

723 int nA,

724 const void *zA,

725 int nB,

726 const void *zB

727 ){

728 SqlCollate p = (SqlCollate )pCtx;

729 Tcl_Obj *pCmd;

730

731 pCmd = Tcl_NewStringObj(p->zScript, -1);

732 Tcl_IncrRefCount(pCmd);

733 Tcl_ListObjAppendElement(p->interp, pCmd, Tcl_NewStringObj(zA, nA));

734 Tcl_ListObjAppendElement(p->interp, pCmd, Tcl_NewStringObj(zB, nB));

735 Tcl_EvalObjEx(p->interp, pCmd, TCL_EVAL_DIRECT);

736 Tcl_DecrRefCount(pCmd);

737 return (atoi(Tcl_GetStringResult(p->interp)));

738 }

739

740 /*

741 ** This routine is called to evaluate an SQL function implemented

742 ** using TCL script.

743 */

744 static void tclSqlFunc(sqlite3_context context, int argc, sqlite3_value*argv){

745 SqlFunc *p = sqlite3_user_data(context);

746 Tcl_Obj *pCmd;

747 int i;

748 int rc;

749

750 if( argc==0 ){

751 /* If there are no arguments to the function, call Tcl_EvalObjEx on the

752 ** script object directly. This allows the TCL compiler to generate

753 ** bytecode for the command on the first invocation and thus make

754 ** subsequent invocations much faster. */

755 pCmd = p->pScript;

756 Tcl_IncrRefCount(pCmd);

757 rc = Tcl_EvalObjEx(p->interp, pCmd, 0);

758 Tcl_DecrRefCount(pCmd);

759 }else{

760 /* If there are arguments to the function, make a shallow copy of the

761 ** script object, lappend the arguments, then evaluate the copy.

762 **

763 ** By "shallow" copy, we mean only the outer list Tcl_Obj is duplicated.

764 ** The new Tcl_Obj contains pointers to the original list elements.

765 ** That way, when Tcl_EvalObjv() is run and shimmers the first element

766 ** of the list to tclCmdNameType, that alternate representation will

767 ** be preserved and reused on the next invocation.

768 */

769 Tcl_Obj **aArg;

770 int nArg;

771 if( Tcl_ListObjGetElements(p->interp, p->pScript, &nArg, &aArg) ){

772 sqlite3_result_error(context, Tcl_GetStringResult(p->interp), -1);

773 return;

774 }

775 pCmd = Tcl_NewListObj(nArg, aArg);

776 Tcl_IncrRefCount(pCmd);

777 for(i=0; i<argc; i++){

778 sqlite3_value *pIn = argv[i];

779 Tcl_Obj *pVal;

780

781 /* Set pVal to contain the i'th column of this row. */

782 switch( sqlite3_value_type(pIn) ){

783 case SQLITE_BLOB: {

784 int bytes = sqlite3_value_bytes(pIn);

785 pVal = Tcl_NewByteArrayObj(sqlite3_value_blob(pIn), bytes);

786 break;

787 }

788 case SQLITE_INTEGER: {

789 sqlite_int64 v = sqlite3_value_int64(pIn);

790 if( v>=-2147483647 && v<=2147483647 ){

791 pVal = Tcl_NewIntObj((int)v);

792 }else{

793 pVal = Tcl_NewWideIntObj(v);

794 }

795 break;

796 }

797 case SQLITE_FLOAT: {

798 double r = sqlite3_value_double(pIn);

799 pVal = Tcl_NewDoubleObj(r);

800 break;

801 }

802 case SQLITE_NULL: {

803 pVal = Tcl_NewStringObj(p->pDb->zNull, -1);

804 break;

805 }

806 default: {

807 int bytes = sqlite3_value_bytes(pIn);

808 pVal = Tcl_NewStringObj((char *)sqlite3_value_text(pIn), bytes);

809 break;

810 }

811 }

812 rc = Tcl_ListObjAppendElement(p->interp, pCmd, pVal);

813 if( rc ){

814 Tcl_DecrRefCount(pCmd);

815 sqlite3_result_error(context, Tcl_GetStringResult(p->interp), -1);

816 return;

817 }

818 }

819 if( !p->useEvalObjv ){

820 /* Tcl_EvalObjEx() will automatically call Tcl_EvalObjv() if pCmd

821 ** is a list without a string representation. To prevent this from

822 ** happening, make sure pCmd has a valid string representation */

823 Tcl_GetString(pCmd);

824 }

825 rc = Tcl_EvalObjEx(p->interp, pCmd, TCL_EVAL_DIRECT);

826 Tcl_DecrRefCount(pCmd);

827 }

828

829 if( rc && rc!=TCL_RETURN ){

830 sqlite3_result_error(context, Tcl_GetStringResult(p->interp), -1);

831 }else{

832 Tcl_Obj *pVar = Tcl_GetObjResult(p->interp);

833 int n;

834 u8 *data;

835 const char *zType = (pVar->typePtr ? pVar->typePtr->name : "");

836 char c = zType[0];

837 if( c=='b' && strcmp(zType,"bytearray")==0 && pVar->bytes==0 ){

838 /* Only return a BLOB type if the Tcl variable is a bytearray and

839 ** has no string representation. */

840 data = Tcl_GetByteArrayFromObj(pVar, &n);

841 sqlite3_result_blob(context, data, n, SQLITE_TRANSIENT);

842 }else if( c=='b' && strcmp(zType,"boolean")==0 ){

843 Tcl_GetIntFromObj(0, pVar, &n);

844 sqlite3_result_int(context, n);

845 }else if( c=='d' && strcmp(zType,"double")==0 ){

846 double r;

847 Tcl_GetDoubleFromObj(0, pVar, &r);

848 sqlite3_result_double(context, r);

849 }else if( (c=='w' && strcmp(zType,"wideInt")==0) \|\|

850 (c=='i' && strcmp(zType,"int")==0) ){

851 Tcl_WideInt v;

852 Tcl_GetWideIntFromObj(0, pVar, &v);

853 sqlite3_result_int64(context, v);

854 }else{

855 data = (unsigned char *)Tcl_GetStringFromObj(pVar, &n);

856 sqlite3_result_text(context, (char *)data, n, SQLITE_TRANSIENT);

857 }

858 }

859 }

860

861 #ifndef SQLITE_OMIT_AUTHORIZATION

862 /*

863 ** This is the authentication function. It appends the authentication

864 ** type code and the two arguments to zCmd[] then invokes the result

865 ** on the interpreter. The reply is examined to determine if the

866 ** authentication fails or succeeds.

867 */

868 static int auth_callback(

869 void *pArg,

870 int code,

871 const char *zArg1,

872 const char *zArg2,

873 const char *zArg3,

874 const char *zArg4

875 #ifdef SQLITE_USER_AUTHENTICATION

876 ,const char *zArg5

877 #endif

878 ){

879 const char *zCode;

880 Tcl_DString str;

881 int rc;

882 const char *zReply;

883 SqliteDb pDb = (SqliteDb)pArg;

884 if( pDb->disableAuth ) return SQLITE_OK;

885

886 switch( code ){

887 case SQLITE_COPY : zCode="SQLITE_COPY"; break;

888 case SQLITE_CREATE_INDEX : zCode="SQLITE_CREATE_INDEX"; break;

889 case SQLITE_CREATE_TABLE : zCode="SQLITE_CREATE_TABLE"; break;

890 case SQLITE_CREATE_TEMP_INDEX : zCode="SQLITE_CREATE_TEMP_INDEX"; break;

891 case SQLITE_CREATE_TEMP_TABLE : zCode="SQLITE_CREATE_TEMP_TABLE"; break;

892 case SQLITE_CREATE_TEMP_TRIGGER: zCode="SQLITE_CREATE_TEMP_TRIGGER"; break;

893 case SQLITE_CREATE_TEMP_VIEW : zCode="SQLITE_CREATE_TEMP_VIEW"; break;

894 case SQLITE_CREATE_TRIGGER : zCode="SQLITE_CREATE_TRIGGER"; break;

895 case SQLITE_CREATE_VIEW : zCode="SQLITE_CREATE_VIEW"; break;

896 case SQLITE_DELETE : zCode="SQLITE_DELETE"; break;

897 case SQLITE_DROP_INDEX : zCode="SQLITE_DROP_INDEX"; break;

898 case SQLITE_DROP_TABLE : zCode="SQLITE_DROP_TABLE"; break;

899 case SQLITE_DROP_TEMP_INDEX : zCode="SQLITE_DROP_TEMP_INDEX"; break;

900 case SQLITE_DROP_TEMP_TABLE : zCode="SQLITE_DROP_TEMP_TABLE"; break;

901 case SQLITE_DROP_TEMP_TRIGGER : zCode="SQLITE_DROP_TEMP_TRIGGER"; break;

902 case SQLITE_DROP_TEMP_VIEW : zCode="SQLITE_DROP_TEMP_VIEW"; break;

903 case SQLITE_DROP_TRIGGER : zCode="SQLITE_DROP_TRIGGER"; break;

904 case SQLITE_DROP_VIEW : zCode="SQLITE_DROP_VIEW"; break;

905 case SQLITE_INSERT : zCode="SQLITE_INSERT"; break;

906 case SQLITE_PRAGMA : zCode="SQLITE_PRAGMA"; break;

907 case SQLITE_READ : zCode="SQLITE_READ"; break;

908 case SQLITE_SELECT : zCode="SQLITE_SELECT"; break;

909 case SQLITE_TRANSACTION : zCode="SQLITE_TRANSACTION"; break;

910 case SQLITE_UPDATE : zCode="SQLITE_UPDATE"; break;

911 case SQLITE_ATTACH : zCode="SQLITE_ATTACH"; break;

912 case SQLITE_DETACH : zCode="SQLITE_DETACH"; break;

913 case SQLITE_ALTER_TABLE : zCode="SQLITE_ALTER_TABLE"; break;

914 case SQLITE_REINDEX : zCode="SQLITE_REINDEX"; break;

915 case SQLITE_ANALYZE : zCode="SQLITE_ANALYZE"; break;

916 case SQLITE_CREATE_VTABLE : zCode="SQLITE_CREATE_VTABLE"; break;

917 case SQLITE_DROP_VTABLE : zCode="SQLITE_DROP_VTABLE"; break;

918 case SQLITE_FUNCTION : zCode="SQLITE_FUNCTION"; break;

919 case SQLITE_SAVEPOINT : zCode="SQLITE_SAVEPOINT"; break;

920 case SQLITE_RECURSIVE : zCode="SQLITE_RECURSIVE"; break;

921 default : zCode="????"; break;

922 }

923 Tcl_DStringInit(&str);

924 Tcl_DStringAppend(&str, pDb->zAuth, -1);

925 Tcl_DStringAppendElement(&str, zCode);

926 Tcl_DStringAppendElement(&str, zArg1 ? zArg1 : "");

927 Tcl_DStringAppendElement(&str, zArg2 ? zArg2 : "");

928 Tcl_DStringAppendElement(&str, zArg3 ? zArg3 : "");

929 Tcl_DStringAppendElement(&str, zArg4 ? zArg4 : "");

930 #ifdef SQLITE_USER_AUTHENTICATION

931 Tcl_DStringAppendElement(&str, zArg5 ? zArg5 : "");

932 #endif

933 rc = Tcl_GlobalEval(pDb->interp, Tcl_DStringValue(&str));

934 Tcl_DStringFree(&str);

935 zReply = rc==TCL_OK ? Tcl_GetStringResult(pDb->interp) : "SQLITE_DENY";

936 if( strcmp(zReply,"SQLITE_OK")==0 ){

937 rc = SQLITE_OK;

938 }else if( strcmp(zReply,"SQLITE_DENY")==0 ){

939 rc = SQLITE_DENY;

940 }else if( strcmp(zReply,"SQLITE_IGNORE")==0 ){

941 rc = SQLITE_IGNORE;

942 }else{

943 rc = 999;

944 }

945 return rc;

946 }

947 #endif /* SQLITE_OMIT_AUTHORIZATION */

948

949 /*

950 ** This routine reads a line of text from FILE in, stores

951 ** the text in memory obtained from malloc() and returns a pointer

952 ** to the text. NULL is returned at end of file, or if malloc()

953 ** fails.

954 **

955 ** The interface is like "readline" but no command-line editing

956 ** is done.

957 **

958 ** copied from shell.c from '.import' command

959 */

960 static char local_getline(char zPrompt, FILE *in){

961 char *zLine;

962 int nLine;

963 int n;

964

965 nLine = 100;

966 zLine = malloc( nLine );

967 if( zLine==0 ) return 0;

968 n = 0;

969 while( 1 ){

970 if( n+100>nLine ){

971 nLine = nLine*2 + 100;

972 zLine = realloc(zLine, nLine);

973 if( zLine==0 ) return 0;

974 }

975 if( fgets(&zLine[n], nLine - n, in)==0 ){

976 if( n==0 ){

977 free(zLine);

978 return 0;

979 }

980 zLine[n] = 0;

981 break;

982 }

983 while( zLine[n] ){ n++; }

984 if( n>0 && zLine[n-1]=='\n' ){

985 n--;

986 zLine[n] = 0;

987 break;

988 }

989 }

990 zLine = realloc( zLine, n+1 );

991 return zLine;

992 }

993

994

995 /*

996 ** This function is part of the implementation of the command:

997 **

998 ** $db transaction [-deferred\|-immediate\|-exclusive] SCRIPT

999 **

1000 ** It is invoked after evaluating the script SCRIPT to commit or rollback

1001 ** the transaction or savepoint opened by the [transaction] command.

1002 */

1003 static int DbTransPostCmd(

1004 ClientData data[], /* data[0] is the Sqlite3Db* for $db */

1005 Tcl_Interp interp, / Tcl interpreter */

1006 int result /* Result of evaluating SCRIPT */

1007 ){

1008 static const char *const azEnd[] = {

1009 "RELEASE _tcl_transaction", /* rc==TCL_ERROR, nTransaction!=0 */

1010 "COMMIT", /* rc!=TCL_ERROR, nTransaction==0 */

1011 "ROLLBACK TO _tcl_transaction ; RELEASE _tcl_transaction",

1012 "ROLLBACK" /* rc==TCL_ERROR, nTransaction==0 */

1013 };

1014 SqliteDb pDb = (SqliteDb)data[0];

1015 int rc = result;

1016 const char *zEnd;

1017

1018 pDb->nTransaction--;

1019 zEnd = azEnd[(rc==TCL_ERROR)*2 + (pDb->nTransaction==0)];

1020

1021 pDb->disableAuth++;

1022 if( sqlite3_exec(pDb->db, zEnd, 0, 0, 0) ){

1023 /* This is a tricky scenario to handle. The most likely cause of an

1024 ** error is that the exec() above was an attempt to commit the

1025 ** top-level transaction that returned SQLITE_BUSY. Or, less likely,

1026 ** that an IO-error has occurred. In either case, throw a Tcl exception

1027 ** and try to rollback the transaction.

1028 **

1029 ** But it could also be that the user executed one or more BEGIN,

1030 ** COMMIT, SAVEPOINT, RELEASE or ROLLBACK commands that are confusing

1031 ** this method's logic. Not clear how this would be best handled.

1032 */

1033 if( rc!=TCL_ERROR ){

1034 Tcl_AppendResult(interp, sqlite3_errmsg(pDb->db), (char*)0);

1035 rc = TCL_ERROR;

1036 }

1037 sqlite3_exec(pDb->db, "ROLLBACK", 0, 0, 0);

1038 }

1039 pDb->disableAuth--;

1040

1041 return rc;

1042 }

1043

1044 /*

1045 ** Unless SQLITE_TEST is defined, this function is a simple wrapper around

1046 ** sqlite3_prepare_v2(). If SQLITE_TEST is defined, then it uses either

1047 ** sqlite3_prepare_v2() or legacy interface sqlite3_prepare(), depending

1048 ** on whether or not the [db_use_legacy_prepare] command has been used to

1049 ** configure the connection.

1050 */

1051 static int dbPrepare(

1052 SqliteDb pDb, / Database object */

1053 const char zSql, / SQL to compile */

1054 sqlite3_stmt *ppStmt, / OUT: Prepared statement */

1055 const char *pzOut / OUT: Pointer to next SQL statement */

1056 ){

1057 #ifdef SQLITE_TEST

1058 if( pDb->bLegacyPrepare ){

1059 return sqlite3_prepare(pDb->db, zSql, -1, ppStmt, pzOut);

1060 }

1061 #endif

1062 return sqlite3_prepare_v2(pDb->db, zSql, -1, ppStmt, pzOut);

1063 }

1064

1065 /*

1066 ** Search the cache for a prepared-statement object that implements the

1067 ** first SQL statement in the buffer pointed to by parameter zIn. If

1068 ** no such prepared-statement can be found, allocate and prepare a new

1069 ** one. In either case, bind the current values of the relevant Tcl

1070 ** variables to any $var, :var or @var variables in the statement. Before

1071 ** returning, set *ppPreStmt to point to the prepared-statement object.

1072 **

1073 ** Output parameter *pzOut is set to point to the next SQL statement in

1074 ** buffer zIn, or to the '\0' byte at the end of zIn if there is no

1075 ** next statement.

1076 **

1077 ** If successful, TCL_OK is returned. Otherwise, TCL_ERROR is returned

1078 ** and an error message loaded into interpreter pDb->interp.

1079 */

1080 static int dbPrepareAndBind(

1081 SqliteDb pDb, / Database object */

1082 char const zIn, / SQL to compile */

1083 char const *pzOut, / OUT: Pointer to next SQL statement */

1084 SqlPreparedStmt *ppPreStmt / OUT: Object used to cache statement */

1085 ){

1086 const char zSql = zIn; / Pointer to first SQL statement in zIn */

1087 sqlite3_stmt pStmt; / Prepared statement object */

1088 SqlPreparedStmt pPreStmt; / Pointer to cached statement */

1089 int nSql; /* Length of zSql in bytes */

1090 int nVar; /* Number of variables in statement */

1091 int iParm = 0; /* Next free entry in apParm */

1092 char c;

1093 int i;

1094 Tcl_Interp *interp = pDb->interp;

1095

1096 *ppPreStmt = 0;

1097

1098 /* Trim spaces from the start of zSql and calculate the remaining length. */

1099 while( (c = zSql[0])==' ' \|\| c=='\t' \|\| c=='\r' \|\| c=='\n' ){ zSql++; }

1100 nSql = strlen30(zSql);

1101

1102 for(pPreStmt = pDb->stmtList; pPreStmt; pPreStmt=pPreStmt->pNext){

1103 int n = pPreStmt->nSql;

1104 if( nSql>=n

1105 && memcmp(pPreStmt->zSql, zSql, n)==0

1106 && (zSql[n]==0 \|\| zSql[n-1]==';')

1107 ){

1108 pStmt = pPreStmt->pStmt;

1109 *pzOut = &zSql[pPreStmt->nSql];

1110

1111 /* When a prepared statement is found, unlink it from the

1112 ** cache list. It will later be added back to the beginning

1113 ** of the cache list in order to implement LRU replacement.

1114 */

1115 if( pPreStmt->pPrev ){

1116 pPreStmt->pPrev->pNext = pPreStmt->pNext;

1117 }else{

1118 pDb->stmtList = pPreStmt->pNext;

1119 }

1120 if( pPreStmt->pNext ){

1121 pPreStmt->pNext->pPrev = pPreStmt->pPrev;

1122 }else{

1123 pDb->stmtLast = pPreStmt->pPrev;

1124 }

1125 pDb->nStmt--;

1126 nVar = sqlite3_bind_parameter_count(pStmt);

1127 break;

1128 }

1129 }

1130

1131 /* If no prepared statement was found. Compile the SQL text. Also allocate

1132 ** a new SqlPreparedStmt structure. */

1133 if( pPreStmt==0 ){

1134 int nByte;

1135

1136 if( SQLITE_OK!=dbPrepare(pDb, zSql, &pStmt, pzOut) ){

1137 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3_errmsg(pDb->db), -1));

1138 return TCL_ERROR;

1139 }

1140 if( pStmt==0 ){

1141 if( SQLITE_OK!=sqlite3_errcode(pDb->db) ){

1142 /* A compile-time error in the statement. */

1143 Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3_errmsg(pDb->db), -1));

1144 return TCL_ERROR;

1145 }else{

1146 /* The statement was a no-op. Continue to the next statement

1147 ** in the SQL string.

1148 */

1149 return TCL_OK;

1150 }

1151 }

1152

1153 assert( pPreStmt==0 );

1154 nVar = sqlite3_bind_parameter_count(pStmt);

1155 nByte = sizeof(SqlPreparedStmt) + nVarsizeof(Tcl_Obj );

1156 pPreStmt = (SqlPreparedStmt*)Tcl_Alloc(nByte);

1157 memset(pPreStmt, 0, nByte);

1158

1159 pPreStmt->pStmt = pStmt;

1160 pPreStmt->nSql = (int)(*pzOut - zSql);

1161 pPreStmt->zSql = sqlite3_sql(pStmt);

1162 pPreStmt->apParm = (Tcl_Obj **)&pPreStmt[1];

1163 #ifdef SQLITE_TEST

1164 if( pPreStmt->zSql==0 ){

1165 char *zCopy = Tcl_Alloc(pPreStmt->nSql + 1);

1166 memcpy(zCopy, zSql, pPreStmt->nSql);

1167 zCopy[pPreStmt->nSql] = '\0';

1168 pPreStmt->zSql = zCopy;

1169 }

1170 #endif

1171 }

1172 assert( pPreStmt );

1173 assert( strlen30(pPreStmt->zSql)==pPreStmt->nSql );

1174 assert( 0==memcmp(pPreStmt->zSql, zSql, pPreStmt->nSql) );

1175

1176 /* Bind values to parameters that begin with $ or : */

1177 for(i=1; i<=nVar; i++){

1178 const char *zVar = sqlite3_bind_parameter_name(pStmt, i);

1179 if( zVar!=0 && (zVar[0]=='$' \|\| zVar[0]==':' \|\| zVar[0]=='@') ){

1180 Tcl_Obj *pVar = Tcl_GetVar2Ex(interp, &zVar[1], 0, 0);

1181 if( pVar ){

1182 int n;

1183 u8 *data;

1184 const char *zType = (pVar->typePtr ? pVar->typePtr->name : "");

1185 char c = zType[0];

1186 if( zVar[0]=='@' \|\|

1187 (c=='b' && strcmp(zType,"bytearray")==0 && pVar->bytes==0) ){

1188 /* Load a BLOB type if the Tcl variable is a bytearray and

1189 ** it has no string representation or the host

1190 ** parameter name begins with "@". */

1191 data = Tcl_GetByteArrayFromObj(pVar, &n);

1192 sqlite3_bind_blob(pStmt, i, data, n, SQLITE_STATIC);

1193 Tcl_IncrRefCount(pVar);

1194 pPreStmt->apParm[iParm++] = pVar;

1195 }else if( c=='b' && strcmp(zType,"boolean")==0 ){

1196 Tcl_GetIntFromObj(interp, pVar, &n);

1197 sqlite3_bind_int(pStmt, i, n);

1198 }else if( c=='d' && strcmp(zType,"double")==0 ){

1199 double r;

1200 Tcl_GetDoubleFromObj(interp, pVar, &r);

1201 sqlite3_bind_double(pStmt, i, r);

1202 }else if( (c=='w' && strcmp(zType,"wideInt")==0) \|\|

1203 (c=='i' && strcmp(zType,"int")==0) ){

1204 Tcl_WideInt v;

1205 Tcl_GetWideIntFromObj(interp, pVar, &v);

1206 sqlite3_bind_int64(pStmt, i, v);

1207 }else{

1208 data = (unsigned char *)Tcl_GetStringFromObj(pVar, &n);

1209 sqlite3_bind_text(pStmt, i, (char *)data, n, SQLITE_STATIC);

1210 Tcl_IncrRefCount(pVar);

1211 pPreStmt->apParm[iParm++] = pVar;

1212 }

1213 }else{

1214 sqlite3_bind_null(pStmt, i);

1215 }

1216 }

1217 }

1218 pPreStmt->nParm = iParm;

1219 *ppPreStmt = pPreStmt;

1220

1221 return TCL_OK;

1222 }

1223

1224 /*

1225 ** Release a statement reference obtained by calling dbPrepareAndBind().

1226 ** There should be exactly one call to this function for each call to

1227 ** dbPrepareAndBind().

1228 **

1229 ** If the discard parameter is non-zero, then the statement is deleted

1230 ** immediately. Otherwise it is added to the LRU list and may be returned

1231 ** by a subsequent call to dbPrepareAndBind().

1232 */

1233 static void dbReleaseStmt(

1234 SqliteDb pDb, / Database handle */

1235 SqlPreparedStmt pPreStmt, / Prepared statement handle to release */

1236 int discard /* True to delete (not cache) the pPreStmt */

1237 ){

1238 int i;

1239

1240 /* Free the bound string and blob parameters */

1241 for(i=0; i<pPreStmt->nParm; i++){

1242 Tcl_DecrRefCount(pPreStmt->apParm[i]);

1243 }

1244 pPreStmt->nParm = 0;

1245

1246 if( pDb->maxStmt<=0 \|\| discard ){

1247 /* If the cache is turned off, deallocated the statement */

1248 dbFreeStmt(pPreStmt);

1249 }else{

1250 /* Add the prepared statement to the beginning of the cache list. */

1251 pPreStmt->pNext = pDb->stmtList;

1252 pPreStmt->pPrev = 0;

1253 if( pDb->stmtList ){

1254 pDb->stmtList->pPrev = pPreStmt;

1255 }

1256 pDb->stmtList = pPreStmt;

1257 if( pDb->stmtLast==0 ){

1258 assert( pDb->nStmt==0 );

1259 pDb->stmtLast = pPreStmt;

1260 }else{

1261 assert( pDb->nStmt>0 );

1262 }

1263 pDb->nStmt++;

1264

1265 /* If we have too many statement in cache, remove the surplus from

1266 ** the end of the cache list. */

1267 while( pDb->nStmt>pDb->maxStmt ){

1268 SqlPreparedStmt *pLast = pDb->stmtLast;

1269 pDb->stmtLast = pLast->pPrev;

1270 pDb->stmtLast->pNext = 0;

1271 pDb->nStmt--;

1272 dbFreeStmt(pLast);

1273 }

1274 }

1275 }

1276

1277 /*

1278 ** Structure used with dbEvalXXX() functions:

1279 **

1280 ** dbEvalInit()

1281 ** dbEvalStep()

1282 ** dbEvalFinalize()

1283 ** dbEvalRowInfo()

1284 ** dbEvalColumnValue()

1285 */

1286 typedef struct DbEvalContext DbEvalContext;

1287 struct DbEvalContext {

1288 SqliteDb pDb; / Database handle */

1289 Tcl_Obj pSql; / Object holding string zSql */

1290 const char zSql; / Remaining SQL to execute */

1291 SqlPreparedStmt pPreStmt; / Current statement */

1292 int nCol; /* Number of columns returned by pStmt */

1293 Tcl_Obj pArray; / Name of array variable */

1294 Tcl_Obj *apColName; / Array of column names */

1295 };

1296

1297 /*

1298 ** Release any cache of column names currently held as part of

1299 ** the DbEvalContext structure passed as the first argument.

1300 */

1301 static void dbReleaseColumnNames(DbEvalContext *p){

1302 if( p->apColName ){

1303 int i;

1304 for(i=0; i<p->nCol; i++){

1305 Tcl_DecrRefCount(p->apColName[i]);

1306 }

1307 Tcl_Free((char *)p->apColName);

1308 p->apColName = 0;

1309 }

1310 p->nCol = 0;

1311 }

1312

1313 /*

1314 ** Initialize a DbEvalContext structure.

1315 **

1316 ** If pArray is not NULL, then it contains the name of a Tcl array

1317 ** variable. The "*" member of this array is set to a list containing

1318 ** the names of the columns returned by the statement as part of each

1319 ** call to dbEvalStep(), in order from left to right. e.g. if the names

1320 ** of the returned columns are a, b and c, it does the equivalent of the

1321 ** tcl command:

1322 **

1323 ** set ${pArray}(*) {a b c}

1324 */

1325 static void dbEvalInit(

1326 DbEvalContext p, / Pointer to structure to initialize */

1327 SqliteDb pDb, / Database handle */

1328 Tcl_Obj pSql, / Object containing SQL script */

1329 Tcl_Obj pArray / Name of Tcl array to set () element of /

1330 ){

1331 memset(p, 0, sizeof(DbEvalContext));

1332 p->pDb = pDb;

1333 p->zSql = Tcl_GetString(pSql);

1334 p->pSql = pSql;

1335 Tcl_IncrRefCount(pSql);

1336 if( pArray ){

1337 p->pArray = pArray;

1338 Tcl_IncrRefCount(pArray);

1339 }

1340 }

1341

1342 /*

1343 ** Obtain information about the row that the DbEvalContext passed as the

1344 ** first argument currently points to.

1345 */

1346 static void dbEvalRowInfo(

1347 DbEvalContext p, / Evaluation context */

1348 int pnCol, / OUT: Number of column names */

1349 Tcl_Obj **papColName / OUT: Array of column names */

1350 ){

1351 /* Compute column names */

1352 if( 0==p->apColName ){

1353 sqlite3_stmt *pStmt = p->pPreStmt->pStmt;

1354 int i; /* Iterator variable */

1355 int nCol; /* Number of columns returned by pStmt */

1356 Tcl_Obj *apColName = 0; / Array of column names */

1357

1358 p->nCol = nCol = sqlite3_column_count(pStmt);

1359 if( nCol>0 && (papColName \|\| p->pArray) ){

1360 apColName = (Tcl_Obj*)Tcl_Alloc( sizeof(Tcl_Obj)*nCol );

1361 for(i=0; i<nCol; i++){

1362 apColName[i] = Tcl_NewStringObj(sqlite3_column_name(pStmt,i), -1);

1363 Tcl_IncrRefCount(apColName[i]);

1364 }

1365 p->apColName = apColName;

1366 }

1367

1368 /* If results are being stored in an array variable, then create

1369 ** the array(*) entry for that array

1370 */

1371 if( p->pArray ){

1372 Tcl_Interp *interp = p->pDb->interp;

1373 Tcl_Obj *pColList = Tcl_NewObj();

1374 Tcl_Obj pStar = Tcl_NewStringObj("", -1);

1375

1376 for(i=0; i<nCol; i++){

1377 Tcl_ListObjAppendElement(interp, pColList, apColName[i]);

1378 }

1379 Tcl_IncrRefCount(pStar);

1380 Tcl_ObjSetVar2(interp, p->pArray, pStar, pColList, 0);

1381 Tcl_DecrRefCount(pStar);

1382 }

1383 }

1384

1385 if( papColName ){

1386 *papColName = p->apColName;

1387 }

1388 if( pnCol ){

1389 *pnCol = p->nCol;

1390 }

1391 }

1392

1393 /*

1394 ** Return one of TCL_OK, TCL_BREAK or TCL_ERROR. If TCL_ERROR is

1395 ** returned, then an error message is stored in the interpreter before

1396 ** returning.

1397 **

1398 ** A return value of TCL_OK means there is a row of data available. The

1399 ** data may be accessed using dbEvalRowInfo() and dbEvalColumnValue(). This

1400 ** is analogous to a return of SQLITE_ROW from sqlite3_step(). If TCL_BREAK

1401 ** is returned, then the SQL script has finished executing and there are

1402 ** no further rows available. This is similar to SQLITE_DONE.

1403 */

1404 static int dbEvalStep(DbEvalContext *p){

1405 const char zPrevSql = 0; / Previous value of p->zSql */

1406

1407 while( p->zSql[0] \|\| p->pPreStmt ){

1408 int rc;

1409 if( p->pPreStmt==0 ){

1410 zPrevSql = (p->zSql==zPrevSql ? 0 : p->zSql);

1411 rc = dbPrepareAndBind(p->pDb, p->zSql, &p->zSql, &p->pPreStmt);

1412 if( rc!=TCL_OK ) return rc;

1413 }else{

1414 int rcs;

1415 SqliteDb *pDb = p->pDb;

1416 SqlPreparedStmt *pPreStmt = p->pPreStmt;

1417 sqlite3_stmt *pStmt = pPreStmt->pStmt;

1418

1419 rcs = sqlite3_step(pStmt);

1420 if( rcs==SQLITE_ROW ){

1421 return TCL_OK;

1422 }

1423 if( p->pArray ){

1424 dbEvalRowInfo(p, 0, 0);

1425 }

1426 rcs = sqlite3_reset(pStmt);

1427

1428 pDb->nStep = sqlite3_stmt_status(pStmt,SQLITE_STMTSTATUS_FULLSCAN_STEP,1);

1429 pDb->nSort = sqlite3_stmt_status(pStmt,SQLITE_STMTSTATUS_SORT,1);

1430 pDb->nIndex = sqlite3_stmt_status(pStmt,SQLITE_STMTSTATUS_AUTOINDEX,1);

1431 dbReleaseColumnNames(p);

1432 p->pPreStmt = 0;

1433

1434 if( rcs!=SQLITE_OK ){

1435 /* If a run-time error occurs, report the error and stop reading

1436 ** the SQL. */

1437 dbReleaseStmt(pDb, pPreStmt, 1);

1438 #if SQLITE_TEST

1439 if( p->pDb->bLegacyPrepare && rcs==SQLITE_SCHEMA && zPrevSql ){

1440 /* If the runtime error was an SQLITE_SCHEMA, and the database

1441 ** handle is configured to use the legacy sqlite3_prepare()

1442 ** interface, retry prepare()/step() on the same SQL statement.

1443 ** This only happens once. If there is a second SQLITE_SCHEMA

1444 ** error, the error will be returned to the caller. */

1445 p->zSql = zPrevSql;

1446 continue;

1447 }

1448 #endif

1449 Tcl_SetObjResult(pDb->interp,

1450 Tcl_NewStringObj(sqlite3_errmsg(pDb->db), -1));

1451 return TCL_ERROR;

1452 }else{

1453 dbReleaseStmt(pDb, pPreStmt, 0);

1454 }

1455 }

1456 }

1457

1458 /* Finished */

1459 return TCL_BREAK;

1460 }

1461

1462 /*

1463 ** Free all resources currently held by the DbEvalContext structure passed

1464 ** as the first argument. There should be exactly one call to this function

1465 ** for each call to dbEvalInit().

1466 */

1467 static void dbEvalFinalize(DbEvalContext *p){

1468 if( p->pPreStmt ){

1469 sqlite3_reset(p->pPreStmt->pStmt);

1470 dbReleaseStmt(p->pDb, p->pPreStmt, 0);

1471 p->pPreStmt = 0;

1472 }

1473 if( p->pArray ){

1474 Tcl_DecrRefCount(p->pArray);

1475 p->pArray = 0;

1476 }

1477 Tcl_DecrRefCount(p->pSql);

1478 dbReleaseColumnNames(p);

1479 }

1480

1481 /*

1482 ** Return a pointer to a Tcl_Obj structure with ref-count 0 that contains

1483 ** the value for the iCol'th column of the row currently pointed to by

1484 ** the DbEvalContext structure passed as the first argument.

1485 */

1486 static Tcl_Obj dbEvalColumnValue(DbEvalContext p, int iCol){

1487 sqlite3_stmt *pStmt = p->pPreStmt->pStmt;

1488 switch( sqlite3_column_type(pStmt, iCol) ){

1489 case SQLITE_BLOB: {

1490 int bytes = sqlite3_column_bytes(pStmt, iCol);

1491 const char *zBlob = sqlite3_column_blob(pStmt, iCol);

1492 if( !zBlob ) bytes = 0;

1493 return Tcl_NewByteArrayObj((u8*)zBlob, bytes);

1494 }

1495 case SQLITE_INTEGER: {

1496 sqlite_int64 v = sqlite3_column_int64(pStmt, iCol);

1497 if( v>=-2147483647 && v<=2147483647 ){

1498 return Tcl_NewIntObj((int)v);

1499 }else{

1500 return Tcl_NewWideIntObj(v);

1501 }

1502 }

1503 case SQLITE_FLOAT: {

1504 return Tcl_NewDoubleObj(sqlite3_column_double(pStmt, iCol));

1505 }

1506 case SQLITE_NULL: {

1507 return Tcl_NewStringObj(p->pDb->zNull, -1);

1508 }

1509 }

1510

1511 return Tcl_NewStringObj((char*)sqlite3_column_text(pStmt, iCol), -1);

1512 }

1513

1514 /*

1515 ** If using Tcl version 8.6 or greater, use the NR functions to avoid

1516 ** recursive evalution of scripts by the [db eval] and [db trans]

1517 ** commands. Even if the headers used while compiling the extension

1518 ** are 8.6 or newer, the code still tests the Tcl version at runtime.

1519 ** This allows stubs-enabled builds to be used with older Tcl libraries.

1520 */

1521 #if TCL_MAJOR_VERSION>8 \|\| (TCL_MAJOR_VERSION==8 && TCL_MINOR_VERSION>=6)

1522 # define SQLITE_TCL_NRE 1

1523 static int DbUseNre(void){

1524 int major, minor;

1525 Tcl_GetVersion(&major, &minor, 0, 0);

1526 return( (major==8 && minor>=6) \|\| major>8 );

1527 }

1528 #else

1529 /*

1530 ** Compiling using headers earlier than 8.6. In this case NR cannot be

1531 ** used, so DbUseNre() to always return zero. Add #defines for the other

1532 ** Tcl_NRxxx() functions to prevent them from causing compilation errors,

1533 ** even though the only invocations of them are within conditional blocks

1534 ** of the form:

1535 **

1536 ** if( DbUseNre() ) { ... }

1537 */

1538 # define SQLITE_TCL_NRE 0

1539 # define DbUseNre() 0

1540 # define Tcl_NRAddCallback(a,b,c,d,e,f) (void)0

1541 # define Tcl_NREvalObj(a,b,c) 0

1542 # define Tcl_NRCreateCommand(a,b,c,d,e,f) (void)0

1543 #endif

1544

1545 /*

1546 ** This function is part of the implementation of the command:

1547 **

1548 ** $db eval SQL ?ARRAYNAME? SCRIPT

1549 */

1550 static int DbEvalNextCmd(

1551 ClientData data[], /* data[0] is the (DbEvalContext) /

1552 Tcl_Interp interp, / Tcl interpreter */

1553 int result /* Result so far */

1554 ){

1555 int rc = result; /* Return code */

1556

1557 /* The first element of the data[] array is a pointer to a DbEvalContext

1558 ** structure allocated using Tcl_Alloc(). The second element of data[]

1559 ** is a pointer to a Tcl_Obj containing the script to run for each row

1560 ** returned by the queries encapsulated in data[0]. */

1561 DbEvalContext p = (DbEvalContext )data[0];

1562 Tcl_Obj pScript = (Tcl_Obj )data[1];

1563 Tcl_Obj *pArray = p->pArray;

1564

1565 while( (rc==TCL_OK \|\| rc==TCL_CONTINUE) && TCL_OK==(rc = dbEvalStep(p)) ){

1566 int i;

1567 int nCol;

1568 Tcl_Obj **apColName;

1569 dbEvalRowInfo(p, &nCol, &apColName);

1570 for(i=0; i<nCol; i++){

1571 Tcl_Obj *pVal = dbEvalColumnValue(p, i);

1572 if( pArray==0 ){

1573 Tcl_ObjSetVar2(interp, apColName[i], 0, pVal, 0);

1574 }else{

1575 Tcl_ObjSetVar2(interp, pArray, apColName[i], pVal, 0);

1576 }

1577 }

1578

1579 /* The required interpreter variables are now populated with the data

1580 ** from the current row. If using NRE, schedule callbacks to evaluate

1581 ** script pScript, then to invoke this function again to fetch the next

1582 ** row (or clean up if there is no next row or the script throws an

1583 ** exception). After scheduling the callbacks, return control to the

1584 ** caller.

1585 **

1586 ** If not using NRE, evaluate pScript directly and continue with the

1587 ** next iteration of this while(...) loop. */

1588 if( DbUseNre() ){

1589 Tcl_NRAddCallback(interp, DbEvalNextCmd, (void)p, (void)pScript, 0, 0);

1590 return Tcl_NREvalObj(interp, pScript, 0);

1591 }else{

1592 rc = Tcl_EvalObjEx(interp, pScript, 0);

1593 }

1594 }

1595

1596 Tcl_DecrRefCount(pScript);

1597 dbEvalFinalize(p);

1598 Tcl_Free((char *)p);

1599

1600 if( rc==TCL_OK \|\| rc==TCL_BREAK ){

1601 Tcl_ResetResult(interp);

1602 rc = TCL_OK;

1603 }

1604 return rc;

1605 }

1606

1607 /*

1608 ** The "sqlite" command below creates a new Tcl command for each

1609 ** connection it opens to an SQLite database. This routine is invoked

1610 ** whenever one of those connection-specific commands is executed

1611 ** in Tcl. For example, if you run Tcl code like this:

1612 **

1613 ** sqlite3 db1 "my_database"

1614 ** db1 close

1615 **

1616 ** The first command opens a connection to the "my_database" database

1617 ** and calls that connection "db1". The second command causes this

1618 ** subroutine to be invoked.

1619 */

1620 static int DbObjCmd(void cd, Tcl_Interp interp, int objc,Tcl_Obj constobjv){

1621 SqliteDb pDb = (SqliteDb)cd;

1622 int choice;

1623 int rc = TCL_OK;

1624 static const char *DB_strs[] = {

1625 "authorizer", "backup", "busy",

1626 "cache", "changes", "close",

1627 "collate", "collation_needed", "commit_hook",

1628 "complete", "copy", "enable_load_extension",

1629 "errorcode", "eval", "exists",

1630 "function", "incrblob", "interrupt",

1631 "last_insert_rowid", "nullvalue", "onecolumn",

1632 "profile", "progress", "rekey",

1633 "restore", "rollback_hook", "status",

1634 "timeout", "total_changes", "trace",

1635 "transaction", "unlock_notify", "update_hook",

1636 "version", "wal_hook", 0

1637 };

1638 enum DB_enum {

1639 DB_AUTHORIZER, DB_BACKUP, DB_BUSY,

1640 DB_CACHE, DB_CHANGES, DB_CLOSE,

1641 DB_COLLATE, DB_COLLATION_NEEDED, DB_COMMIT_HOOK,

1642 DB_COMPLETE, DB_COPY, DB_ENABLE_LOAD_EXTENSION,

1643 DB_ERRORCODE, DB_EVAL, DB_EXISTS,

1644 DB_FUNCTION, DB_INCRBLOB, DB_INTERRUPT,

1645 DB_LAST_INSERT_ROWID, DB_NULLVALUE, DB_ONECOLUMN,

1646 DB_PROFILE, DB_PROGRESS, DB_REKEY,

1647 DB_RESTORE, DB_ROLLBACK_HOOK, DB_STATUS,

1648 DB_TIMEOUT, DB_TOTAL_CHANGES, DB_TRACE,

1649 DB_TRANSACTION, DB_UNLOCK_NOTIFY, DB_UPDATE_HOOK,

1650 DB_VERSION, DB_WAL_HOOK

1651 };

1652 /* don't leave trailing commas on DB_enum, it confuses the AIX xlc compiler */

1653

1654 if( objc<2 ){

1655 Tcl_WrongNumArgs(interp, 1, objv, "SUBCOMMAND ...");

1656 return TCL_ERROR;

1657 }

1658 if( Tcl_GetIndexFromObj(interp, objv[1], DB_strs, "option", 0, &choice) ){

1659 return TCL_ERROR;

1660 }

1661

1662 switch( (enum DB_enum)choice ){

1663

1664 /* $db authorizer ?CALLBACK?

1665 **

1666 ** Invoke the given callback to authorize each SQL operation as it is

1667 ** compiled. 5 arguments are appended to the callback before it is

1668 ** invoked:

1669 **

1670 ** (1) The authorization type (ex: SQLITE_CREATE_TABLE, SQLITE_INSERT, ...)

1671 ** (2) First descriptive name (depends on authorization type)

1672 ** (3) Second descriptive name

1673 ** (4) Name of the database (ex: "main", "temp")

1674 ** (5) Name of trigger that is doing the access

1675 **

1676 ** The callback should return on of the following strings: SQLITE_OK,

1677 ** SQLITE_IGNORE, or SQLITE_DENY. Any other return value is an error.

1678 **

1679 ** If this method is invoked with no arguments, the current authorization

1680 ** callback string is returned.

1681 */

1682 case DB_AUTHORIZER: {

1683 #ifdef SQLITE_OMIT_AUTHORIZATION

1684 Tcl_AppendResult(interp, "authorization not available in this build",

1685 (char*)0);

1686 return TCL_ERROR;

1687 #else

1688 if( objc>3 ){

1689 Tcl_WrongNumArgs(interp, 2, objv, "?CALLBACK?");

1690 return TCL_ERROR;

1691 }else if( objc==2 ){

1692 if( pDb->zAuth ){

1693 Tcl_AppendResult(interp, pDb->zAuth, (char*)0);

1694 }

1695 }else{

1696 char *zAuth;

1697 int len;

1698 if( pDb->zAuth ){

1699 Tcl_Free(pDb->zAuth);

1700 }

1701 zAuth = Tcl_GetStringFromObj(objv[2], &len);

1702 if( zAuth && len>0 ){

1703 pDb->zAuth = Tcl_Alloc( len + 1 );

1704 memcpy(pDb->zAuth, zAuth, len+1);

1705 }else{

1706 pDb->zAuth = 0;

1707 }

1708 if( pDb->zAuth ){

1709 typedef int (*sqlite3_auth_cb)(

1710 void,int,const char,const char*,

1711 const char,const char);

1712 pDb->interp = interp;

1713 sqlite3_set_authorizer(pDb->db,(sqlite3_auth_cb)auth_callback,pDb);

1714 }else{

1715 sqlite3_set_authorizer(pDb->db, 0, 0);

1716 }

1717 }

1718 #endif

1719 break;

1720 }

1721

1722 /* $db backup ?DATABASE? FILENAME

1723 **

1724 ** Open or create a database file named FILENAME. Transfer the

1725 ** content of local database DATABASE (default: "main") into the

1726 ** FILENAME database.

1727 */

1728 case DB_BACKUP: {

1729 const char *zDestFile;

1730 const char *zSrcDb;

1731 sqlite3 *pDest;

1732 sqlite3_backup *pBackup;

1733

1734 if( objc==3 ){

1735 zSrcDb = "main";

1736 zDestFile = Tcl_GetString(objv[2]);

1737 }else if( objc==4 ){

1738 zSrcDb = Tcl_GetString(objv[2]);

1739 zDestFile = Tcl_GetString(objv[3]);

1740 }else{

1741 Tcl_WrongNumArgs(interp, 2, objv, "?DATABASE? FILENAME");

1742 return TCL_ERROR;

1743 }

1744 rc = sqlite3_open(zDestFile, &pDest);

1745 if( rc!=SQLITE_OK ){

1746 Tcl_AppendResult(interp, "cannot open target database: ",

1747 sqlite3_errmsg(pDest), (char*)0);

1748 sqlite3_close(pDest);

1749 return TCL_ERROR;

1750 }

1751 pBackup = sqlite3_backup_init(pDest, "main", pDb->db, zSrcDb);

1752 if( pBackup==0 ){

1753 Tcl_AppendResult(interp, "backup failed: ",

1754 sqlite3_errmsg(pDest), (char*)0);

1755 sqlite3_close(pDest);

1756 return TCL_ERROR;

1757 }

1758 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){}

1759 sqlite3_backup_finish(pBackup);

1760 if( rc==SQLITE_DONE ){

1761 rc = TCL_OK;

1762 }else{

1763 Tcl_AppendResult(interp, "backup failed: ",

1764 sqlite3_errmsg(pDest), (char*)0);

1765 rc = TCL_ERROR;

1766 }

1767 sqlite3_close(pDest);

1768 break;

1769 }

1770

1771 /* $db busy ?CALLBACK?

1772 **

1773 ** Invoke the given callback if an SQL statement attempts to open

1774 ** a locked database file.

1775 */

1776 case DB_BUSY: {

1777 if( objc>3 ){

1778 Tcl_WrongNumArgs(interp, 2, objv, "CALLBACK");

1779 return TCL_ERROR;

1780 }else if( objc==2 ){

1781 if( pDb->zBusy ){

1782 Tcl_AppendResult(interp, pDb->zBusy, (char*)0);

1783 }

1784 }else{

1785 char *zBusy;

1786 int len;

1787 if( pDb->zBusy ){

1788 Tcl_Free(pDb->zBusy);

1789 }

1790 zBusy = Tcl_GetStringFromObj(objv[2], &len);

1791 if( zBusy && len>0 ){

1792 pDb->zBusy = Tcl_Alloc( len + 1 );

1793 memcpy(pDb->zBusy, zBusy, len+1);

1794 }else{

1795 pDb->zBusy = 0;

1796 }

1797 if( pDb->zBusy ){

1798 pDb->interp = interp;

1799 sqlite3_busy_handler(pDb->db, DbBusyHandler, pDb);

1800 }else{

1801 sqlite3_busy_handler(pDb->db, 0, 0);

1802 }

1803 }

1804 break;

1805 }

1806

1807 /* $db cache flush

1808 ** $db cache size n

1809 **

1810 ** Flush the prepared statement cache, or set the maximum number of

1811 ** cached statements.

1812 */

1813 case DB_CACHE: {

1814 char *subCmd;

1815 int n;

1816

1817 if( objc<=2 ){

1818 Tcl_WrongNumArgs(interp, 1, objv, "cache option ?arg?");

1819 return TCL_ERROR;

1820 }

1821 subCmd = Tcl_GetStringFromObj( objv[2], 0 );

1822 if( *subCmd=='f' && strcmp(subCmd,"flush")==0 ){

1823 if( objc!=3 ){

1824 Tcl_WrongNumArgs(interp, 2, objv, "flush");

1825 return TCL_ERROR;

1826 }else{

1827 flushStmtCache( pDb );

1828 }

1829 }else if( *subCmd=='s' && strcmp(subCmd,"size")==0 ){

1830 if( objc!=4 ){

1831 Tcl_WrongNumArgs(interp, 2, objv, "size n");

1832 return TCL_ERROR;

1833 }else{

1834 if( TCL_ERROR==Tcl_GetIntFromObj(interp, objv[3], &n) ){

1835 Tcl_AppendResult( interp, "cannot convert \"",

1836 Tcl_GetStringFromObj(objv[3],0), "\" to integer", (char*)0);

1837 return TCL_ERROR;

1838 }else{

1839 if( n<0 ){

1840 flushStmtCache( pDb );

1841 n = 0;

1842 }else if( n>MAX_PREPARED_STMTS ){

1843 n = MAX_PREPARED_STMTS;

1844 }

1845 pDb->maxStmt = n;

1846 }

1847 }

1848 }else{

1849 Tcl_AppendResult( interp, "bad option \"",

1850 Tcl_GetStringFromObj(objv[2],0), "\": must be flush or size",

1851 (char*)0);

1852 return TCL_ERROR;

1853 }

1854 break;

1855 }

1856

1857 /* $db changes

1858 **

1859 ** Return the number of rows that were modified, inserted, or deleted by

1860 ** the most recent INSERT, UPDATE or DELETE statement, not including

1861 ** any changes made by trigger programs.

1862 */

1863 case DB_CHANGES: {

1864 Tcl_Obj *pResult;

1865 if( objc!=2 ){

1866 Tcl_WrongNumArgs(interp, 2, objv, "");

1867 return TCL_ERROR;

1868 }

1869 pResult = Tcl_GetObjResult(interp);

1870 Tcl_SetIntObj(pResult, sqlite3_changes(pDb->db));

1871 break;

1872 }

1873

1874 /* $db close

1875 **

1876 ** Shutdown the database

1877 */

1878 case DB_CLOSE: {

1879 Tcl_DeleteCommand(interp, Tcl_GetStringFromObj(objv[0], 0));

1880 break;

1881 }

1882

1883 /*

1884 ** $db collate NAME SCRIPT

1885 **

1886 ** Create a new SQL collation function called NAME. Whenever

1887 ** that function is called, invoke SCRIPT to evaluate the function.

1888 */

1889 case DB_COLLATE: {

1890 SqlCollate *pCollate;

1891 char *zName;

1892 char *zScript;

1893 int nScript;

1894 if( objc!=4 ){

1895 Tcl_WrongNumArgs(interp, 2, objv, "NAME SCRIPT");

1896 return TCL_ERROR;

1897 }

1898 zName = Tcl_GetStringFromObj(objv[2], 0);

1899 zScript = Tcl_GetStringFromObj(objv[3], &nScript);

1900 pCollate = (SqlCollate)Tcl_Alloc( sizeof(pCollate) + nScript + 1 );

1901 if( pCollate==0 ) return TCL_ERROR;

1902 pCollate->interp = interp;

1903 pCollate->pNext = pDb->pCollate;

1904 pCollate->zScript = (char*)&pCollate[1];

1905 pDb->pCollate = pCollate;

1906 memcpy(pCollate->zScript, zScript, nScript+1);

1907 if( sqlite3_create_collation(pDb->db, zName, SQLITE_UTF8,

1908 pCollate, tclSqlCollate) ){

1909 Tcl_SetResult(interp, (char *)sqlite3_errmsg(pDb->db), TCL_VOLATILE);

1910 return TCL_ERROR;

1911 }

1912 break;

1913 }

1914

1915 /*

1916 ** $db collation_needed SCRIPT

1917 **

1918 ** Create a new SQL collation function called NAME. Whenever

1919 ** that function is called, invoke SCRIPT to evaluate the function.

1920 */

1921 case DB_COLLATION_NEEDED: {

1922 if( objc!=3 ){

1923 Tcl_WrongNumArgs(interp, 2, objv, "SCRIPT");

1924 return TCL_ERROR;

1925 }

1926 if( pDb->pCollateNeeded ){

1927 Tcl_DecrRefCount(pDb->pCollateNeeded);

1928 }

1929 pDb->pCollateNeeded = Tcl_DuplicateObj(objv[2]);

1930 Tcl_IncrRefCount(pDb->pCollateNeeded);

1931 sqlite3_collation_needed(pDb->db, pDb, tclCollateNeeded);

1932 break;

1933 }

1934

1935 /* $db commit_hook ?CALLBACK?

1936 **

1937 ** Invoke the given callback just before committing every SQL transaction.

1938 ** If the callback throws an exception or returns non-zero, then the

1939 ** transaction is aborted. If CALLBACK is an empty string, the callback

1940 ** is disabled.

1941 */

1942 case DB_COMMIT_HOOK: {

1943 if( objc>3 ){

1944 Tcl_WrongNumArgs(interp, 2, objv, "?CALLBACK?");

1945 return TCL_ERROR;

1946 }else if( objc==2 ){

1947 if( pDb->zCommit ){

1948 Tcl_AppendResult(interp, pDb->zCommit, (char*)0);

1949 }

1950 }else{

1951 const char *zCommit;

1952 int len;

1953 if( pDb->zCommit ){

1954 Tcl_Free(pDb->zCommit);

1955 }

1956 zCommit = Tcl_GetStringFromObj(objv[2], &len);

1957 if( zCommit && len>0 ){

1958 pDb->zCommit = Tcl_Alloc( len + 1 );

1959 memcpy(pDb->zCommit, zCommit, len+1);

1960 }else{

1961 pDb->zCommit = 0;

1962 }

1963 if( pDb->zCommit ){

1964 pDb->interp = interp;

1965 sqlite3_commit_hook(pDb->db, DbCommitHandler, pDb);

1966 }else{

1967 sqlite3_commit_hook(pDb->db, 0, 0);

1968 }

1969 }

1970 break;

1971 }

1972

1973 /* $db complete SQL

1974 **

1975 ** Return TRUE if SQL is a complete SQL statement. Return FALSE if

1976 ** additional lines of input are needed. This is similar to the

1977 ** built-in "info complete" command of Tcl.

1978 */

1979 case DB_COMPLETE: {

1980 #ifndef SQLITE_OMIT_COMPLETE

1981 Tcl_Obj *pResult;

1982 int isComplete;

1983 if( objc!=3 ){

1984 Tcl_WrongNumArgs(interp, 2, objv, "SQL");

1985 return TCL_ERROR;

1986 }

1987 isComplete = sqlite3_complete( Tcl_GetStringFromObj(objv[2], 0) );

1988 pResult = Tcl_GetObjResult(interp);

1989 Tcl_SetBooleanObj(pResult, isComplete);

1990 #endif

1991 break;

1992 }

1993

1994 /* $db copy conflict-algorithm table filename ?SEPARATOR? ?NULLINDICATOR?

1995 **

1996 ** Copy data into table from filename, optionally using SEPARATOR

1997 ** as column separators. If a column contains a null string, or the

1998 ** value of NULLINDICATOR, a NULL is inserted for the column.

1999 ** conflict-algorithm is one of the sqlite conflict algorithms:

2000 ** rollback, abort, fail, ignore, replace

2001 ** On success, return the number of lines processed, not necessarily same

2002 ** as 'db changes' due to conflict-algorithm selected.

2003 **

2004 ** This code is basically an implementation/enhancement of

2005 ** the sqlite3 shell.c ".import" command.

2006 **

2007 ** This command usage is equivalent to the sqlite2.x COPY statement,

2008 ** which imports file data into a table using the PostgreSQL COPY file format:

2009 ** $db copy $conflit_algo $table_name $filename \t \\N

2010 */

2011 case DB_COPY: {

2012 char zTable; / Insert data into this table */

2013 char zFile; / The file from which to extract data */

2014 char zConflict; / The conflict algorithm to use */

2015 sqlite3_stmt pStmt; / A statement */

2016 int nCol; /* Number of columns in the table */

2017 int nByte; /* Number of bytes in an SQL string */

2018 int i, j; /* Loop counters */

2019 int nSep; /* Number of bytes in zSep[] */

2020 int nNull; /* Number of bytes in zNull[] */

2021 char zSql; / An SQL statement */

2022 char zLine; / A single line of input from the file */

2023 char *azCol; / zLine[] broken up into columns */

2024 const char zCommit; / How to commit changes */

2025 FILE in; / The input file */

2026 int lineno = 0; /* Line number of input file */

2027 char zLineNum[80]; /* Line number print buffer */

2028 Tcl_Obj pResult; / interp result */

2029

2030 const char *zSep;

2031 const char *zNull;

2032 if( objc<5 \|\| objc>7 ){

2033 Tcl_WrongNumArgs(interp, 2, objv,

2034 "CONFLICT-ALGORITHM TABLE FILENAME ?SEPARATOR? ?NULLINDICATOR?");

2035 return TCL_ERROR;

2036 }

2037 if( objc>=6 ){

2038 zSep = Tcl_GetStringFromObj(objv[5], 0);

2039 }else{

2040 zSep = "\t";

2041 }

2042 if( objc>=7 ){

2043 zNull = Tcl_GetStringFromObj(objv[6], 0);

2044 }else{

2045 zNull = "";

2046 }

2047 zConflict = Tcl_GetStringFromObj(objv[2], 0);

2048 zTable = Tcl_GetStringFromObj(objv[3], 0);

2049 zFile = Tcl_GetStringFromObj(objv[4], 0);

2050 nSep = strlen30(zSep);

2051 nNull = strlen30(zNull);

2052 if( nSep==0 ){

2053 Tcl_AppendResult(interp,"Error: non-null separator required for copy",

2054 (char*)0);

2055 return TCL_ERROR;

2056 }

2057 if(strcmp(zConflict, "rollback") != 0 &&

2058 strcmp(zConflict, "abort" ) != 0 &&

2059 strcmp(zConflict, "fail" ) != 0 &&

2060 strcmp(zConflict, "ignore" ) != 0 &&

2061 strcmp(zConflict, "replace" ) != 0 ) {

2062 Tcl_AppendResult(interp, "Error: \"", zConflict,

2063 "\", conflict-algorithm must be one of: rollback, "

2064 "abort, fail, ignore, or replace", (char*)0);

2065 return TCL_ERROR;

2066 }

2067 zSql = sqlite3_mprintf("SELECT * FROM '%q'", zTable);

2068 if( zSql==0 ){

2069 Tcl_AppendResult(interp, "Error: no such table: ", zTable, (char*)0);

2070 return TCL_ERROR;

2071 }

2072 nByte = strlen30(zSql);

2073 rc = sqlite3_prepare(pDb->db, zSql, -1, &pStmt, 0);

2074 sqlite3_free(zSql);

2075 if( rc ){

2076 Tcl_AppendResult(interp, "Error: ", sqlite3_errmsg(pDb->db), (char*)0);

2077 nCol = 0;

2078 }else{

2079 nCol = sqlite3_column_count(pStmt);

2080 }

2081 sqlite3_finalize(pStmt);

2082 if( nCol==0 ) {

2083 return TCL_ERROR;

2084 }

2085 zSql = malloc( nByte + 50 + nCol*2 );

2086 if( zSql==0 ) {

2087 Tcl_AppendResult(interp, "Error: can't malloc()", (char*)0);

2088 return TCL_ERROR;

2089 }

2090 sqlite3_snprintf(nByte+50, zSql, "INSERT OR %q INTO '%q' VALUES(?",

2091 zConflict, zTable);

2092 j = strlen30(zSql);

2093 for(i=1; i<nCol; i++){

2094 zSql[j++] = ',';

2095 zSql[j++] = '?';

2096 }

2097 zSql[j++] = ')';

2098 zSql[j] = 0;

2099 rc = sqlite3_prepare(pDb->db, zSql, -1, &pStmt, 0);

2100 free(zSql);

2101 if( rc ){

2102 Tcl_AppendResult(interp, "Error: ", sqlite3_errmsg(pDb->db), (char*)0);

2103 sqlite3_finalize(pStmt);

2104 return TCL_ERROR;

2105 }

2106 in = fopen(zFile, "rb");

2107 if( in==0 ){

2108 Tcl_AppendResult(interp, "Error: cannot open file: ", zFile, NULL);

2109 sqlite3_finalize(pStmt);

2110 return TCL_ERROR;

2111 }

2112 azCol = malloc( sizeof(azCol[0])*(nCol+1) );

2113 if( azCol==0 ) {

2114 Tcl_AppendResult(interp, "Error: can't malloc()", (char*)0);

2115 fclose(in);

2116 return TCL_ERROR;

2117 }

2118 (void)sqlite3_exec(pDb->db, "BEGIN", 0, 0, 0);

2119 zCommit = "COMMIT";

2120 while( (zLine = local_getline(0, in))!=0 ){

2121 char *z;

2122 lineno++;

2123 azCol[0] = zLine;

2124 for(i=0, z=zLine; *z; z++){

2125 if( *z==zSep[0] && strncmp(z, zSep, nSep)==0 ){

2126 *z = 0;

2127 i++;

2128 if( i<nCol ){

2129 azCol[i] = &z[nSep];

2130 z += nSep-1;

2131 }

2132 }

2133 }

2134 if( i+1!=nCol ){

2135 char *zErr;

2136 int nErr = strlen30(zFile) + 200;

2137 zErr = malloc(nErr);

2138 if( zErr ){

2139 sqlite3_snprintf(nErr, zErr,

2140 "Error: %s line %d: expected %d columns of data but found %d",

2141 zFile, lineno, nCol, i+1);

2142 Tcl_AppendResult(interp, zErr, (char*)0);

2143 free(zErr);

2144 }

2145 zCommit = "ROLLBACK";

2146 break;

2147 }

2148 for(i=0; i<nCol; i++){

2149 /* check for null data, if so, bind as null */

2150 if( (nNull>0 && strcmp(azCol[i], zNull)==0)

2151 \|\| strlen30(azCol[i])==0

2152 ){

2153 sqlite3_bind_null(pStmt, i+1);

2154 }else{

2155 sqlite3_bind_text(pStmt, i+1, azCol[i], -1, SQLITE_STATIC);

2156 }

2157 }

2158 sqlite3_step(pStmt);

2159 rc = sqlite3_reset(pStmt);

2160 free(zLine);

2161 if( rc!=SQLITE_OK ){

2162 Tcl_AppendResult(interp,"Error: ", sqlite3_errmsg(pDb->db), (char*)0);

2163 zCommit = "ROLLBACK";

2164 break;

2165 }

2166 }

2167 free(azCol);

2168 fclose(in);

2169 sqlite3_finalize(pStmt);

2170 (void)sqlite3_exec(pDb->db, zCommit, 0, 0, 0);

2171

2172 if( zCommit[0] == 'C' ){

2173 /* success, set result as number of lines processed */

2174 pResult = Tcl_GetObjResult(interp);

2175 Tcl_SetIntObj(pResult, lineno);

2176 rc = TCL_OK;

2177 }else{

2178 /* failure, append lineno where failed */

2179 sqlite3_snprintf(sizeof(zLineNum), zLineNum,"%d",lineno);

2180 Tcl_AppendResult(interp,", failed while processing line: ",zLineNum,

2181 (char*)0);

2182 rc = TCL_ERROR;

2183 }

2184 break;

2185 }

2186

2187 /*

2188 ** $db enable_load_extension BOOLEAN

2189 **

2190 ** Turn the extension loading feature on or off. It if off by

2191 ** default.

2192 */

2193 case DB_ENABLE_LOAD_EXTENSION: {

2194 #ifndef SQLITE_OMIT_LOAD_EXTENSION

2195 int onoff;

2196 if( objc!=3 ){

2197 Tcl_WrongNumArgs(interp, 2, objv, "BOOLEAN");

2198 return TCL_ERROR;

2199 }

2200 if( Tcl_GetBooleanFromObj(interp, objv[2], &onoff) ){

2201 return TCL_ERROR;

2202 }

2203 sqlite3_enable_load_extension(pDb->db, onoff);

2204 break;

2205 #else

2206 Tcl_AppendResult(interp, "extension loading is turned off at compile-time",

2207 (char*)0);

2208 return TCL_ERROR;

2209 #endif

2210 }

2211

2212 /*

2213 ** $db errorcode

2214 **

2215 ** Return the numeric error code that was returned by the most recent

2216 ** call to sqlite3_exec().

2217 */

2218 case DB_ERRORCODE: {

2219 Tcl_SetObjResult(interp, Tcl_NewIntObj(sqlite3_errcode(pDb->db)));

2220 break;

2221 }

2222

2223 /*

2224 ** $db exists $sql

2225 ** $db onecolumn $sql

2226 **

2227 ** The onecolumn method is the equivalent of:

2228 ** lindex [$db eval $sql] 0

2229 */

2230 case DB_EXISTS:

2231 case DB_ONECOLUMN: {

2232 DbEvalContext sEval;

2233 if( objc!=3 ){

2234 Tcl_WrongNumArgs(interp, 2, objv, "SQL");

2235 return TCL_ERROR;

2236 }

2237

2238 dbEvalInit(&sEval, pDb, objv[2], 0);

2239 rc = dbEvalStep(&sEval);

2240 if( choice==DB_ONECOLUMN ){

2241 if( rc==TCL_OK ){

2242 Tcl_SetObjResult(interp, dbEvalColumnValue(&sEval, 0));

2243 }else if( rc==TCL_BREAK ){

2244 Tcl_ResetResult(interp);

2245 }

2246 }else if( rc==TCL_BREAK \|\| rc==TCL_OK ){

2247 Tcl_SetObjResult(interp, Tcl_NewBooleanObj(rc==TCL_OK));

2248 }

2249 dbEvalFinalize(&sEval);

2250

2251 if( rc==TCL_BREAK ){

2252 rc = TCL_OK;

2253 }

2254 break;

2255 }

2256

2257 /*

2258 ** $db eval $sql ?array? ?{ ...code... }?

2259 **

2260 ** The SQL statement in $sql is evaluated. For each row, the values are

2261 ** placed in elements of the array named "array" and ...code... is executed.

2262 ** If "array" and "code" are omitted, then no callback is every invoked.

2263 ** If "array" is an empty string, then the values are placed in variables

2264 ** that have the same name as the fields extracted by the query.

2265 */

2266 case DB_EVAL: {

2267 if( objc<3 \|\| objc>5 ){

2268 Tcl_WrongNumArgs(interp, 2, objv, "SQL ?ARRAY-NAME? ?SCRIPT?");

2269 return TCL_ERROR;

2270 }

2271

2272 if( objc==3 ){

2273 DbEvalContext sEval;

2274 Tcl_Obj *pRet = Tcl_NewObj();

2275 Tcl_IncrRefCount(pRet);

2276 dbEvalInit(&sEval, pDb, objv[2], 0);

2277 while( TCL_OK==(rc = dbEvalStep(&sEval)) ){

2278 int i;

2279 int nCol;

2280 dbEvalRowInfo(&sEval, &nCol, 0);

2281 for(i=0; i<nCol; i++){

2282 Tcl_ListObjAppendElement(interp, pRet, dbEvalColumnValue(&sEval, i));

2283 }

2284 }

2285 dbEvalFinalize(&sEval);

2286 if( rc==TCL_BREAK ){

2287 Tcl_SetObjResult(interp, pRet);

2288 rc = TCL_OK;

2289 }

2290 Tcl_DecrRefCount(pRet);

2291 }else{

2292 ClientData cd[2];

2293 DbEvalContext *p;

2294 Tcl_Obj *pArray = 0;

2295 Tcl_Obj *pScript;

2296

2297 if( objc==5 && (char )Tcl_GetString(objv[3]) ){

2298 pArray = objv[3];

2299 }

2300 pScript = objv[objc-1];

2301 Tcl_IncrRefCount(pScript);

2302

2303 p = (DbEvalContext *)Tcl_Alloc(sizeof(DbEvalContext));

2304 dbEvalInit(p, pDb, objv[2], pArray);

2305

2306 cd[0] = (void *)p;

2307 cd[1] = (void *)pScript;

2308 rc = DbEvalNextCmd(cd, interp, TCL_OK);

2309 }

2310 break;

2311 }

2312

2313 /*

2314 ** $db function NAME [-argcount N] SCRIPT

2315 **

2316 ** Create a new SQL function called NAME. Whenever that function is

2317 ** called, invoke SCRIPT to evaluate the function.

2318 */

2319 case DB_FUNCTION: {

2320 SqlFunc *pFunc;

2321 Tcl_Obj *pScript;

2322 char *zName;

2323 int nArg = -1;

2324 if( objc==6 ){

2325 const char *z = Tcl_GetString(objv[3]);

2326 int n = strlen30(z);

2327 if( n>2 && strncmp(z, "-argcount",n)==0 ){

2328 if( Tcl_GetIntFromObj(interp, objv[4], &nArg) ) return TCL_ERROR;

2329 if( nArg<0 ){

2330 Tcl_AppendResult(interp, "number of arguments must be non-negative",

2331 (char*)0);

2332 return TCL_ERROR;

2333 }

2334 }

2335 pScript = objv[5];

2336 }else if( objc!=4 ){

2337 Tcl_WrongNumArgs(interp, 2, objv, "NAME [-argcount N] SCRIPT");

2338 return TCL_ERROR;

2339 }else{

2340 pScript = objv[3];

2341 }

2342 zName = Tcl_GetStringFromObj(objv[2], 0);

2343 pFunc = findSqlFunc(pDb, zName);

2344 if( pFunc==0 ) return TCL_ERROR;

2345 if( pFunc->pScript ){

2346 Tcl_DecrRefCount(pFunc->pScript);

2347 }

2348 pFunc->pScript = pScript;

2349 Tcl_IncrRefCount(pScript);

2350 pFunc->useEvalObjv = safeToUseEvalObjv(interp, pScript);

2351 rc = sqlite3_create_function(pDb->db, zName, nArg, SQLITE_UTF8,

2352 pFunc, tclSqlFunc, 0, 0);

2353 if( rc!=SQLITE_OK ){

2354 rc = TCL_ERROR;

2355 Tcl_SetResult(interp, (char *)sqlite3_errmsg(pDb->db), TCL_VOLATILE);

2356 }

2357 break;

2358 }

2359

2360 /*

2361 ** $db incrblob ?-readonly? ?DB? TABLE COLUMN ROWID

2362 */

2363 case DB_INCRBLOB: {

2364 #ifdef SQLITE_OMIT_INCRBLOB

2365 Tcl_AppendResult(interp, "incrblob not available in this build", (char*)0);

2366 return TCL_ERROR;

2367 #else

2368 int isReadonly = 0;

2369 const char *zDb = "main";

2370 const char *zTable;

2371 const char *zColumn;

2372 Tcl_WideInt iRow;

2373

2374 /* Check for the -readonly option */

2375 if( objc>3 && strcmp(Tcl_GetString(objv[2]), "-readonly")==0 ){

2376 isReadonly = 1;

2377 }

2378

2379 if( objc!=(5+isReadonly) && objc!=(6+isReadonly) ){

2380 Tcl_WrongNumArgs(interp, 2, objv, "?-readonly? ?DB? TABLE COLUMN ROWID");

2381 return TCL_ERROR;

2382 }

2383

2384 if( objc==(6+isReadonly) ){

2385 zDb = Tcl_GetString(objv[2]);

2386 }

2387 zTable = Tcl_GetString(objv[objc-3]);

2388 zColumn = Tcl_GetString(objv[objc-2]);

2389 rc = Tcl_GetWideIntFromObj(interp, objv[objc-1], &iRow);

2390

2391 if( rc==TCL_OK ){

2392 rc = createIncrblobChannel(

2393 interp, pDb, zDb, zTable, zColumn, (sqlite3_int64)iRow, isReadonly

2394 );

2395 }

2396 #endif

2397 break;

2398 }

2399

2400 /*

2401 ** $db interrupt

2402 **

2403 ** Interrupt the execution of the inner-most SQL interpreter. This

2404 ** causes the SQL statement to return an error of SQLITE_INTERRUPT.

2405 */

2406 case DB_INTERRUPT: {

2407 sqlite3_interrupt(pDb->db);

2408 break;

2409 }

2410

2411 /*

2412 ** $db nullvalue ?STRING?

2413 **

2414 ** Change text used when a NULL comes back from the database. If ?STRING?

2415 ** is not present, then the current string used for NULL is returned.

2416 ** If STRING is present, then STRING is returned.

2417 **

2418 */

2419 case DB_NULLVALUE: {

2420 if( objc!=2 && objc!=3 ){

2421 Tcl_WrongNumArgs(interp, 2, objv, "NULLVALUE");

2422 return TCL_ERROR;

2423 }

2424 if( objc==3 ){

2425 int len;

2426 char *zNull = Tcl_GetStringFromObj(objv[2], &len);

2427 if( pDb->zNull ){

2428 Tcl_Free(pDb->zNull);

2429 }

2430 if( zNull && len>0 ){

2431 pDb->zNull = Tcl_Alloc( len + 1 );

2432 memcpy(pDb->zNull, zNull, len);

2433 pDb->zNull[len] = '\0';

2434 }else{

2435 pDb->zNull = 0;

2436 }

2437 }

2438 Tcl_SetObjResult(interp, Tcl_NewStringObj(pDb->zNull, -1));

2439 break;

2440 }

2441

2442 /*

2443 ** $db last_insert_rowid

2444 **

2445 ** Return an integer which is the ROWID for the most recent insert.

2446 */

2447 case DB_LAST_INSERT_ROWID: {

2448 Tcl_Obj *pResult;

2449 Tcl_WideInt rowid;

2450 if( objc!=2 ){

2451 Tcl_WrongNumArgs(interp, 2, objv, "");

2452 return TCL_ERROR;

2453 }

2454 rowid = sqlite3_last_insert_rowid(pDb->db);

2455 pResult = Tcl_GetObjResult(interp);

2456 Tcl_SetWideIntObj(pResult, rowid);

2457 break;

2458 }

2459

2460 /*

2461 ** The DB_ONECOLUMN method is implemented together with DB_EXISTS.

2462 */

2463

2464 /* $db progress ?N CALLBACK?

2465 **

2466 ** Invoke the given callback every N virtual machine opcodes while executing

2467 ** queries.

2468 */

2469 case DB_PROGRESS: {

2470 if( objc==2 ){

2471 if( pDb->zProgress ){

2472 Tcl_AppendResult(interp, pDb->zProgress, (char*)0);

2473 }

2474 }else if( objc==4 ){

2475 char *zProgress;

2476 int len;

2477 int N;

2478 if( TCL_OK!=Tcl_GetIntFromObj(interp, objv[2], &N) ){

2479 return TCL_ERROR;

2480 };

2481 if( pDb->zProgress ){

2482 Tcl_Free(pDb->zProgress);

2483 }

2484 zProgress = Tcl_GetStringFromObj(objv[3], &len);

2485 if( zProgress && len>0 ){

2486 pDb->zProgress = Tcl_Alloc( len + 1 );

2487 memcpy(pDb->zProgress, zProgress, len+1);

2488 }else{

2489 pDb->zProgress = 0;

2490 }

2491 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK

2492 if( pDb->zProgress ){

2493 pDb->interp = interp;

2494 sqlite3_progress_handler(pDb->db, N, DbProgressHandler, pDb);

2495 }else{

2496 sqlite3_progress_handler(pDb->db, 0, 0, 0);

2497 }

2498 #endif

2499 }else{

2500 Tcl_WrongNumArgs(interp, 2, objv, "N CALLBACK");

2501 return TCL_ERROR;

2502 }

2503 break;

2504 }

2505

2506 /* $db profile ?CALLBACK?

2507 **

2508 ** Make arrangements to invoke the CALLBACK routine after each SQL statement

2509 ** that has run. The text of the SQL and the amount of elapse time are

2510 ** appended to CALLBACK before the script is run.

2511 */

2512 case DB_PROFILE: {

2513 if( objc>3 ){

2514 Tcl_WrongNumArgs(interp, 2, objv, "?CALLBACK?");

2515 return TCL_ERROR;

2516 }else if( objc==2 ){

2517 if( pDb->zProfile ){

2518 Tcl_AppendResult(interp, pDb->zProfile, (char*)0);

2519 }

2520 }else{

2521 char *zProfile;

2522 int len;

2523 if( pDb->zProfile ){

2524 Tcl_Free(pDb->zProfile);

2525 }

2526 zProfile = Tcl_GetStringFromObj(objv[2], &len);

2527 if( zProfile && len>0 ){

2528 pDb->zProfile = Tcl_Alloc( len + 1 );

2529 memcpy(pDb->zProfile, zProfile, len+1);

2530 }else{

2531 pDb->zProfile = 0;

2532 }

2533 #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT)

2534 if( pDb->zProfile ){

2535 pDb->interp = interp;

2536 sqlite3_profile(pDb->db, DbProfileHandler, pDb);

2537 }else{

2538 sqlite3_profile(pDb->db, 0, 0);

2539 }

2540 #endif

2541 }

2542 break;

2543 }

2544

2545 /*

2546 ** $db rekey KEY

2547 **

2548 ** Change the encryption key on the currently open database.

2549 */

2550 case DB_REKEY: {

2551 #ifdef SQLITE_HAS_CODEC

2552 int nKey;

2553 void *pKey;

2554 #endif

2555 if( objc!=3 ){

2556 Tcl_WrongNumArgs(interp, 2, objv, "KEY");

2557 return TCL_ERROR;

2558 }

2559 #ifdef SQLITE_HAS_CODEC

2560 pKey = Tcl_GetByteArrayFromObj(objv[2], &nKey);

2561 rc = sqlite3_rekey(pDb->db, pKey, nKey);

2562 if( rc ){

2563 Tcl_AppendResult(interp, sqlite3_errstr(rc), (char*)0);

2564 rc = TCL_ERROR;

2565 }

2566 #endif

2567 break;

2568 }

2569

2570 /* $db restore ?DATABASE? FILENAME

2571 **

2572 ** Open a database file named FILENAME. Transfer the content

2573 ** of FILENAME into the local database DATABASE (default: "main").

2574 */

2575 case DB_RESTORE: {

2576 const char *zSrcFile;

2577 const char *zDestDb;

2578 sqlite3 *pSrc;

2579 sqlite3_backup *pBackup;

2580 int nTimeout = 0;

2581

2582 if( objc==3 ){

2583 zDestDb = "main";

2584 zSrcFile = Tcl_GetString(objv[2]);

2585 }else if( objc==4 ){

2586 zDestDb = Tcl_GetString(objv[2]);

2587 zSrcFile = Tcl_GetString(objv[3]);

2588 }else{

2589 Tcl_WrongNumArgs(interp, 2, objv, "?DATABASE? FILENAME");

2590 return TCL_ERROR;

2591 }

2592 rc = sqlite3_open_v2(zSrcFile, &pSrc, SQLITE_OPEN_READONLY, 0);

2593 if( rc!=SQLITE_OK ){

2594 Tcl_AppendResult(interp, "cannot open source database: ",

2595 sqlite3_errmsg(pSrc), (char*)0);

2596 sqlite3_close(pSrc);

2597 return TCL_ERROR;

2598 }

2599 pBackup = sqlite3_backup_init(pDb->db, zDestDb, pSrc, "main");

2600 if( pBackup==0 ){

2601 Tcl_AppendResult(interp, "restore failed: ",

2602 sqlite3_errmsg(pDb->db), (char*)0);

2603 sqlite3_close(pSrc);

2604 return TCL_ERROR;

2605 }

2606 while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK

2607 \|\| rc==SQLITE_BUSY ){

2608 if( rc==SQLITE_BUSY ){

2609 if( nTimeout++ >= 3 ) break;

2610 sqlite3_sleep(100);

2611 }

2612 }

2613 sqlite3_backup_finish(pBackup);

2614 if( rc==SQLITE_DONE ){

2615 rc = TCL_OK;

2616 }else if( rc==SQLITE_BUSY \|\| rc==SQLITE_LOCKED ){

2617 Tcl_AppendResult(interp, "restore failed: source database busy",

2618 (char*)0);

2619 rc = TCL_ERROR;

2620 }else{

2621 Tcl_AppendResult(interp, "restore failed: ",

2622 sqlite3_errmsg(pDb->db), (char*)0);

2623 rc = TCL_ERROR;

2624 }

2625 sqlite3_close(pSrc);

2626 break;

2627 }

2628

2629 /*

2630 ** $db status (step\|sort\|autoindex)

2631 **

2632 ** Display SQLITE_STMTSTATUS_FULLSCAN_STEP or

2633 ** SQLITE_STMTSTATUS_SORT for the most recent eval.

2634 */

2635 case DB_STATUS: {

2636 int v;

2637 const char *zOp;

2638 if( objc!=3 ){

2639 Tcl_WrongNumArgs(interp, 2, objv, "(step\|sort\|autoindex)");

2640 return TCL_ERROR;

2641 }

2642 zOp = Tcl_GetString(objv[2]);

2643 if( strcmp(zOp, "step")==0 ){

2644 v = pDb->nStep;

2645 }else if( strcmp(zOp, "sort")==0 ){

2646 v = pDb->nSort;

2647 }else if( strcmp(zOp, "autoindex")==0 ){

2648 v = pDb->nIndex;

2649 }else{

2650 Tcl_AppendResult(interp,

2651 "bad argument: should be autoindex, step, or sort",

2652 (char*)0);

2653 return TCL_ERROR;

2654 }

2655 Tcl_SetObjResult(interp, Tcl_NewIntObj(v));

2656 break;

2657 }

2658

2659 /*

2660 ** $db timeout MILLESECONDS

2661 **

2662 ** Delay for the number of milliseconds specified when a file is locked.

2663 */

2664 case DB_TIMEOUT: {

2665 int ms;

2666 if( objc!=3 ){

2667 Tcl_WrongNumArgs(interp, 2, objv, "MILLISECONDS");

2668 return TCL_ERROR;

2669 }

2670 if( Tcl_GetIntFromObj(interp, objv[2], &ms) ) return TCL_ERROR;

2671 sqlite3_busy_timeout(pDb->db, ms);

2672 break;

2673 }

2674

2675 /*

2676 ** $db total_changes

2677 **

2678 ** Return the number of rows that were modified, inserted, or deleted

2679 ** since the database handle was created.

2680 */

2681 case DB_TOTAL_CHANGES: {

2682 Tcl_Obj *pResult;

2683 if( objc!=2 ){

2684 Tcl_WrongNumArgs(interp, 2, objv, "");

2685 return TCL_ERROR;

2686 }

2687 pResult = Tcl_GetObjResult(interp);

2688 Tcl_SetIntObj(pResult, sqlite3_total_changes(pDb->db));

2689 break;

2690 }

2691

2692 /* $db trace ?CALLBACK?

2693 **

2694 ** Make arrangements to invoke the CALLBACK routine for each SQL statement

2695 ** that is executed. The text of the SQL is appended to CALLBACK before

2696 ** it is executed.

2697 */

2698 case DB_TRACE: {

2699 if( objc>3 ){

2700 Tcl_WrongNumArgs(interp, 2, objv, "?CALLBACK?");

2701 return TCL_ERROR;

2702 }else if( objc==2 ){

2703 if( pDb->zTrace ){

2704 Tcl_AppendResult(interp, pDb->zTrace, (char*)0);

2705 }

2706 }else{

2707 char *zTrace;

2708 int len;

2709 if( pDb->zTrace ){

2710 Tcl_Free(pDb->zTrace);

2711 }

2712 zTrace = Tcl_GetStringFromObj(objv[2], &len);

2713 if( zTrace && len>0 ){

2714 pDb->zTrace = Tcl_Alloc( len + 1 );

2715 memcpy(pDb->zTrace, zTrace, len+1);

2716 }else{

2717 pDb->zTrace = 0;

2718 }

2719 #if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT)

2720 if( pDb->zTrace ){

2721 pDb->interp = interp;

2722 sqlite3_trace(pDb->db, DbTraceHandler, pDb);

2723 }else{

2724 sqlite3_trace(pDb->db, 0, 0);

2725 }

2726 #endif

2727 }

2728 break;

2729 }

2730

2731 /* $db transaction [-deferred\|-immediate\|-exclusive] SCRIPT

2732 **

2733 ** Start a new transaction (if we are not already in the midst of a

2734 ** transaction) and execute the TCL script SCRIPT. After SCRIPT

2735 ** completes, either commit the transaction or roll it back if SCRIPT

2736 ** throws an exception. Or if no new transation was started, do nothing.

2737 ** pass the exception on up the stack.

2738 **

2739 ** This command was inspired by Dave Thomas's talk on Ruby at the

2740 ** 2005 O'Reilly Open Source Convention (OSCON).

2741 */

2742 case DB_TRANSACTION: {

2743 Tcl_Obj *pScript;

2744 const char *zBegin = "SAVEPOINT _tcl_transaction";

2745 if( objc!=3 && objc!=4 ){

2746 Tcl_WrongNumArgs(interp, 2, objv, "[TYPE] SCRIPT");

2747 return TCL_ERROR;

2748 }

2749

2750 if( pDb->nTransaction==0 && objc==4 ){

2751 static const char *TTYPE_strs[] = {

2752 "deferred", "exclusive", "immediate", 0

2753 };

2754 enum TTYPE_enum {

2755 TTYPE_DEFERRED, TTYPE_EXCLUSIVE, TTYPE_IMMEDIATE

2756 };

2757 int ttype;

2758 if( Tcl_GetIndexFromObj(interp, objv[2], TTYPE_strs, "transaction type",

2759 0, &ttype) ){

2760 return TCL_ERROR;

2761 }

2762 switch( (enum TTYPE_enum)ttype ){

2763 case TTYPE_DEFERRED: /* no-op */; break;

2764 case TTYPE_EXCLUSIVE: zBegin = "BEGIN EXCLUSIVE"; break;

2765 case TTYPE_IMMEDIATE: zBegin = "BEGIN IMMEDIATE"; break;

2766 }

2767 }

2768 pScript = objv[objc-1];

2769

2770 /* Run the SQLite BEGIN command to open a transaction or savepoint. */

2771 pDb->disableAuth++;

2772 rc = sqlite3_exec(pDb->db, zBegin, 0, 0, 0);

2773 pDb->disableAuth--;

2774 if( rc!=SQLITE_OK ){

2775 Tcl_AppendResult(interp, sqlite3_errmsg(pDb->db), (char*)0);

2776 return TCL_ERROR;

2777 }

2778 pDb->nTransaction++;

2779

2780 /* If using NRE, schedule a callback to invoke the script pScript, then

2781 ** a second callback to commit (or rollback) the transaction or savepoint

2782 ** opened above. If not using NRE, evaluate the script directly, then

2783 ** call function DbTransPostCmd() to commit (or rollback) the transaction

2784 ** or savepoint. */

2785 if( DbUseNre() ){

2786 Tcl_NRAddCallback(interp, DbTransPostCmd, cd, 0, 0, 0);

2787 (void)Tcl_NREvalObj(interp, pScript, 0);

2788 }else{

2789 rc = DbTransPostCmd(&cd, interp, Tcl_EvalObjEx(interp, pScript, 0));

2790 }

2791 break;

2792 }

2793

2794 /*

2795 ** $db unlock_notify ?script?

2796 */

2797 case DB_UNLOCK_NOTIFY: {

2798 #ifndef SQLITE_ENABLE_UNLOCK_NOTIFY

2799 Tcl_AppendResult(interp, "unlock_notify not available in this build",

2800 (char*)0);

2801 rc = TCL_ERROR;

2802 #else

2803 if( objc!=2 && objc!=3 ){

2804 Tcl_WrongNumArgs(interp, 2, objv, "?SCRIPT?");

2805 rc = TCL_ERROR;

2806 }else{

2807 void (xNotify)(void *, int) = 0;

2808 void *pNotifyArg = 0;

2809

2810 if( pDb->pUnlockNotify ){

2811 Tcl_DecrRefCount(pDb->pUnlockNotify);

2812 pDb->pUnlockNotify = 0;

2813 }

2814

2815 if( objc==3 ){

2816 xNotify = DbUnlockNotify;

2817 pNotifyArg = (void *)pDb;

2818 pDb->pUnlockNotify = objv[2];

2819 Tcl_IncrRefCount(pDb->pUnlockNotify);

2820 }

2821

2822 if( sqlite3_unlock_notify(pDb->db, xNotify, pNotifyArg) ){

2823 Tcl_AppendResult(interp, sqlite3_errmsg(pDb->db), (char*)0);

2824 rc = TCL_ERROR;

2825 }

2826 }

2827 #endif

2828 break;

2829 }

2830

2831 /*

2832 ** $db wal_hook ?script?

2833 ** $db update_hook ?script?

2834 ** $db rollback_hook ?script?

2835 */

2836 case DB_WAL_HOOK:

2837 case DB_UPDATE_HOOK:

2838 case DB_ROLLBACK_HOOK: {

2839

2840 /* set ppHook to point at pUpdateHook or pRollbackHook, depending on

2841 ** whether [$db update_hook] or [$db rollback_hook] was invoked.

2842 */

2843 Tcl_Obj **ppHook;

2844 if( choice==DB_UPDATE_HOOK ){

2845 ppHook = &pDb->pUpdateHook;

2846 }else if( choice==DB_WAL_HOOK ){

2847 ppHook = &pDb->pWalHook;

2848 }else{

2849 ppHook = &pDb->pRollbackHook;

2850 }

2851

2852 if( objc!=2 && objc!=3 ){

2853 Tcl_WrongNumArgs(interp, 2, objv, "?SCRIPT?");

2854 return TCL_ERROR;

2855 }

2856 if( *ppHook ){

2857 Tcl_SetObjResult(interp, *ppHook);

2858 if( objc==3 ){

2859 Tcl_DecrRefCount(*ppHook);

2860 *ppHook = 0;

2861 }

2862 }

2863 if( objc==3 ){

2864 assert( !(*ppHook) );

2865 if( Tcl_GetCharLength(objv[2])>0 ){

2866 *ppHook = objv[2];

2867 Tcl_IncrRefCount(*ppHook);

2868 }

2869 }

2870

2871 sqlite3_update_hook(pDb->db, (pDb->pUpdateHook?DbUpdateHandler:0), pDb);

2872 sqlite3_rollback_hook(pDb->db,(pDb->pRollbackHook?DbRollbackHandler:0),pDb);

2873 sqlite3_wal_hook(pDb->db,(pDb->pWalHook?DbWalHandler:0),pDb);

2874

2875 break;

2876 }

2877

2878 /* $db version

2879 **

2880 ** Return the version string for this database.

2881 */

2882 case DB_VERSION: {

2883 Tcl_SetResult(interp, (char *)sqlite3_libversion(), TCL_STATIC);

2884 break;

2885 }

2886

2887

2888 } /* End of the SWITCH statement */

2889 return rc;

2890 }

2891

2892 #if SQLITE_TCL_NRE

2893 /*

2894 ** Adaptor that provides an objCmd interface to the NRE-enabled

2895 ** interface implementation.

2896 */

2897 static int DbObjCmdAdaptor(

2898 void *cd,

2899 Tcl_Interp *interp,

2900 int objc,

2901 Tcl_Obj constobjv

2902 ){

2903 return Tcl_NRCallObjProc(interp, DbObjCmd, cd, objc, objv);

2904 }

2905 #endif /* SQLITE_TCL_NRE */

2906

2907 /*

2908 ** sqlite3 DBNAME FILENAME ?-vfs VFSNAME? ?-key KEY? ?-readonly BOOLEAN?

2909 ** ?-create BOOLEAN? ?-nomutex BOOLEAN?

2910 **

2911 ** This is the main Tcl command. When the "sqlite" Tcl command is

2912 ** invoked, this routine runs to process that command.

2913 **

2914 ** The first argument, DBNAME, is an arbitrary name for a new

2915 ** database connection. This command creates a new command named

2916 ** DBNAME that is used to control that connection. The database

2917 ** connection is deleted when the DBNAME command is deleted.

2918 **

2919 ** The second argument is the name of the database file.

2920 **

2921 */

2922 static int DbMain(void cd, Tcl_Interp interp, int objc,Tcl_Obj constobjv){

2923 SqliteDb *p;

2924 const char *zArg;

2925 char *zErrMsg;

2926 int i;

2927 const char *zFile;

2928 const char *zVfs = 0;

2929 int flags;

2930 Tcl_DString translatedFilename;

2931 #ifdef SQLITE_HAS_CODEC

2932 void *pKey = 0;

2933 int nKey = 0;

2934 #endif

2935 int rc;

2936

2937 /* In normal use, each TCL interpreter runs in a single thread. So

2938 ** by default, we can turn of mutexing on SQLite database connections.

2939 ** However, for testing purposes it is useful to have mutexes turned

2940 ** on. So, by default, mutexes default off. But if compiled with

2941 ** SQLITE_TCL_DEFAULT_FULLMUTEX then mutexes default on.

2942 */

2943 #ifdef SQLITE_TCL_DEFAULT_FULLMUTEX

2944 flags = SQLITE_OPEN_READWRITE \| SQLITE_OPEN_CREATE \| SQLITE_OPEN_FULLMUTEX;

2945 #else

2946 flags = SQLITE_OPEN_READWRITE \| SQLITE_OPEN_CREATE \| SQLITE_OPEN_NOMUTEX;

2947 #endif

2948

2949 if( objc==2 ){

2950 zArg = Tcl_GetStringFromObj(objv[1], 0);

2951 if( strcmp(zArg,"-version")==0 ){

2952 Tcl_AppendResult(interp,sqlite3_libversion(), (char*)0);

2953 return TCL_OK;

2954 }

2955 if( strcmp(zArg,"-has-codec")==0 ){

2956 #ifdef SQLITE_HAS_CODEC

2957 Tcl_AppendResult(interp,"1",(char*)0);

2958 #else

2959 Tcl_AppendResult(interp,"0",(char*)0);

2960 #endif

2961 return TCL_OK;

2962 }

2963 }

2964 for(i=3; i+1<objc; i+=2){

2965 zArg = Tcl_GetString(objv[i]);

2966 if( strcmp(zArg,"-key")==0 ){

2967 #ifdef SQLITE_HAS_CODEC

2968 pKey = Tcl_GetByteArrayFromObj(objv[i+1], &nKey);

2969 #endif

2970 }else if( strcmp(zArg, "-vfs")==0 ){

2971 zVfs = Tcl_GetString(objv[i+1]);

2972 }else if( strcmp(zArg, "-readonly")==0 ){

2973 int b;

2974 if( Tcl_GetBooleanFromObj(interp, objv[i+1], &b) ) return TCL_ERROR;

2975 if( b ){

2976 flags &= ~(SQLITE_OPEN_READWRITE\|SQLITE_OPEN_CREATE);

2977 flags \|= SQLITE_OPEN_READONLY;

2978 }else{

2979 flags &= ~SQLITE_OPEN_READONLY;

2980 flags \|= SQLITE_OPEN_READWRITE;

2981 }

2982 }else if( strcmp(zArg, "-create")==0 ){

2983 int b;

2984 if( Tcl_GetBooleanFromObj(interp, objv[i+1], &b) ) return TCL_ERROR;

2985 if( b && (flags & SQLITE_OPEN_READONLY)==0 ){

2986 flags \|= SQLITE_OPEN_CREATE;

2987 }else{

2988 flags &= ~SQLITE_OPEN_CREATE;

2989 }

2990 }else if( strcmp(zArg, "-nomutex")==0 ){

2991 int b;

2992 if( Tcl_GetBooleanFromObj(interp, objv[i+1], &b) ) return TCL_ERROR;

2993 if( b ){

2994 flags \|= SQLITE_OPEN_NOMUTEX;

2995 flags &= ~SQLITE_OPEN_FULLMUTEX;

2996 }else{

2997 flags &= ~SQLITE_OPEN_NOMUTEX;

2998 }

2999 }else if( strcmp(zArg, "-fullmutex")==0 ){

3000 int b;

3001 if( Tcl_GetBooleanFromObj(interp, objv[i+1], &b) ) return TCL_ERROR;

3002 if( b ){

3003 flags \|= SQLITE_OPEN_FULLMUTEX;

3004 flags &= ~SQLITE_OPEN_NOMUTEX;

3005 }else{

3006 flags &= ~SQLITE_OPEN_FULLMUTEX;

3007 }

3008 }else if( strcmp(zArg, "-uri")==0 ){

3009 int b;

3010 if( Tcl_GetBooleanFromObj(interp, objv[i+1], &b) ) return TCL_ERROR;

3011 if( b ){

3012 flags \|= SQLITE_OPEN_URI;

3013 }else{

3014 flags &= ~SQLITE_OPEN_URI;

3015 }

3016 }else{

3017 Tcl_AppendResult(interp, "unknown option: ", zArg, (char*)0);

3018 return TCL_ERROR;

3019 }

3020 }

3021 if( objc<3 \|\| (objc&1)!=1 ){

3022 Tcl_WrongNumArgs(interp, 1, objv,

3023 "HANDLE FILENAME ?-vfs VFSNAME? ?-readonly BOOLEAN? ?-create BOOLEAN?"

3024 " ?-nomutex BOOLEAN? ?-fullmutex BOOLEAN? ?-uri BOOLEAN?"

3025 #ifdef SQLITE_HAS_CODEC

3026 " ?-key CODECKEY?"

3027 #endif

3028 );

3029 return TCL_ERROR;

3030 }

3031 zErrMsg = 0;

3032 p = (SqliteDb)Tcl_Alloc( sizeof(p) );

3033 if( p==0 ){

3034 Tcl_SetResult(interp, (char *)"malloc failed", TCL_STATIC);

3035 return TCL_ERROR;

3036 }

3037 memset(p, 0, sizeof(*p));

3038 zFile = Tcl_GetStringFromObj(objv[2], 0);

3039 zFile = Tcl_TranslateFileName(interp, zFile, &translatedFilename);

3040 rc = sqlite3_open_v2(zFile, &p->db, flags, zVfs);

3041 Tcl_DStringFree(&translatedFilename);

3042 if( p->db ){

3043 if( SQLITE_OK!=sqlite3_errcode(p->db) ){

3044 zErrMsg = sqlite3_mprintf("%s", sqlite3_errmsg(p->db));

3045 sqlite3_close(p->db);

3046 p->db = 0;

3047 }

3048 }else{

3049 zErrMsg = sqlite3_mprintf("%s", sqlite3_errstr(rc));

3050 }

3051 #ifdef SQLITE_HAS_CODEC

3052 if( p->db ){

3053 sqlite3_key(p->db, pKey, nKey);

3054 }

3055 #endif

3056 if( p->db==0 ){

3057 Tcl_SetResult(interp, zErrMsg, TCL_VOLATILE);

3058 Tcl_Free((char*)p);

3059 sqlite3_free(zErrMsg);

3060 return TCL_ERROR;

3061 }

3062 p->maxStmt = NUM_PREPARED_STMTS;

3063 p->interp = interp;

3064 zArg = Tcl_GetStringFromObj(objv[1], 0);

3065 if( DbUseNre() ){

3066 Tcl_NRCreateCommand(interp, zArg, DbObjCmdAdaptor, DbObjCmd,

3067 (char*)p, DbDeleteCmd);

3068 }else{

3069 Tcl_CreateObjCommand(interp, zArg, DbObjCmd, (char*)p, DbDeleteCmd);

3070 }

3071 return TCL_OK;

3072 }

3073

3074 /*

3075 ** Provide a dummy Tcl_InitStubs if we are using this as a static

3076 ** library.

3077 */

3078 #ifndef USE_TCL_STUBS

3079 # undef Tcl_InitStubs

3080 # define Tcl_InitStubs(a,b,c) TCL_VERSION

3081 #endif

3082

3083 /*

3084 ** Make sure we have a PACKAGE_VERSION macro defined. This will be

3085 ** defined automatically by the TEA makefile. But other makefiles

3086 ** do not define it.

3087 */

3088 #ifndef PACKAGE_VERSION

3089 # define PACKAGE_VERSION SQLITE_VERSION

3090 #endif

3091

3092 /*

3093 ** Initialize this module.

3094 **

3095 ** This Tcl module contains only a single new Tcl command named "sqlite".

3096 ** (Hence there is no namespace. There is no point in using a namespace

3097 ** if the extension only supplies one new name!) The "sqlite" command is

3098 ** used to open a new SQLite database. See the DbMain() routine above

3099 ** for additional information.

3100 **

3101 ** The EXTERN macros are required by TCL in order to work on windows.

3102 */

3103 EXTERN int Sqlite3_Init(Tcl_Interp *interp){

3104 int rc = Tcl_InitStubs(interp, "8.4", 0)==0 ? TCL_ERROR : TCL_OK;

3105 if( rc==TCL_OK ){

3106 Tcl_CreateObjCommand(interp, "sqlite3", (Tcl_ObjCmdProc*)DbMain, 0, 0);

3107 #ifndef SQLITE_3_SUFFIX_ONLY

3108 /* The "sqlite" alias is undocumented. It is here only to support

3109 ** legacy scripts. All new scripts should use only the "sqlite3"

3110 ** command. */

3111 Tcl_CreateObjCommand(interp, "sqlite", (Tcl_ObjCmdProc*)DbMain, 0, 0);

3112 #endif

3113 rc = Tcl_PkgProvide(interp, "sqlite3", PACKAGE_VERSION);

3114 }

3115 return rc;

3116 }

3117 EXTERN int Tclsqlite3_Init(Tcl_Interp *interp){ return Sqlite3_Init(interp); }

3118 EXTERN int Sqlite3_Unload(Tcl_Interp *interp, int flags){ return TCL_OK; }

3119 EXTERN int Tclsqlite3_Unload(Tcl_Interp *interp, int flags){ return TCL_OK; }

3120

3121 /* Because it accesses the file-system and uses persistent state, SQLite

3122 ** is not considered appropriate for safe interpreters. Hence, we deliberately

3123 ** omit the _SafeInit() interfaces.

3124 */

3125

3126 #ifndef SQLITE_3_SUFFIX_ONLY

3127 int Sqlite_Init(Tcl_Interp *interp){ return Sqlite3_Init(interp); }

3128 int Tclsqlite_Init(Tcl_Interp *interp){ return Sqlite3_Init(interp); }

3129 int Sqlite_Unload(Tcl_Interp *interp, int flags){ return TCL_OK; }

3130 int Tclsqlite_Unload(Tcl_Interp *interp, int flags){ return TCL_OK; }

3131 #endif

3132

3133 #ifdef TCLSH

3134 /*****************************************************************************

3135 ** All of the code that follows is used to build standalone TCL interpreters

3136 ** that are statically linked with SQLite. Enable these by compiling

3137 ** with -DTCLSH=n where n can be 1 or 2. An n of 1 generates a standard

3138 ** tclsh but with SQLite built in. An n of 2 generates the SQLite space

3139 ** analysis program.

3140 */

3141

3142 #if defined(SQLITE_TEST) \|\| defined(SQLITE_TCLMD5)

3143 /*

3144 * This code implements the MD5 message-digest algorithm.

3145 * The algorithm is due to Ron Rivest. This code was

3146 * written by Colin Plumb in 1993, no copyright is claimed.

3147 * This code is in the public domain; do with it what you wish.

3148 *

3149 * Equivalent code is available from RSA Data Security, Inc.

3150 * This code has been tested against that, and is equivalent,

3151 * except that you don't need to include two pages of legalese

3152 * with every copy.

3153 *

3154 * To compute the message digest of a chunk of bytes, declare an

3155 * MD5Context structure, pass it to MD5Init, call MD5Update as

3156 * needed on buffers full of bytes, and then call MD5Final, which

3157 * will fill a supplied 16-byte array with the digest.

3158 */

3159

3160 /*

3161 * If compiled on a machine that doesn't have a 32-bit integer,

3162 * you just set "uint32" to the appropriate datatype for an

3163 * unsigned 32-bit integer. For example:

3164 *

3165 * cc -Duint32='unsigned long' md5.c

3166 *

3167 */

3168 #ifndef uint32

3169 # define uint32 unsigned int

3170 #endif

3171

3172 struct MD5Context {

3173 int isInit;

3174 uint32 buf[4];

3175 uint32 bits[2];

3176 unsigned char in[64];

3177 };

3178 typedef struct MD5Context MD5Context;

3179

3180 /*

3181 * Note: this code is harmless on little-endian machines.

3182 */

3183 static void byteReverse (unsigned char *buf, unsigned longs){

3184 uint32 t;

3185 do {

3186 t = (uint32)((unsigned)buf[3]<<8 \| buf[2]) << 16 \|

3187 ((unsigned)buf[1]<<8 \| buf[0]);

3188 (uint32 )buf = t;

3189 buf += 4;

3190 } while (--longs);

3191 }

3192 /* The four core functions - F1 is optimized somewhat */

3193

3194 /* #define F1(x, y, z) (x & y \| ~x & z) */

3195 #define F1(x, y, z) (z ^ (x & (y ^ z)))

3196 #define F2(x, y, z) F1(z, x, y)

3197 #define F3(x, y, z) (x ^ y ^ z)

3198 #define F4(x, y, z) (y ^ (x \| ~z))

3199

3200 /* This is the central step in the MD5 algorithm. */

3201 #define MD5STEP(f, w, x, y, z, data, s) \

3202 ( w += f(x, y, z) + data, w = w<<s \| w>>(32-s), w += x )

3203

3204 /*

3205 * The core of the MD5 algorithm, this alters an existing MD5 hash to

3206 * reflect the addition of 16 longwords of new data. MD5Update blocks

3207 * the data and converts bytes into longwords for this routine.

3208 */

3209 static void MD5Transform(uint32 buf[4], const uint32 in[16]){

3210 register uint32 a, b, c, d;

3211

3212 a = buf[0];

3213 b = buf[1];

3214 c = buf[2];

3215 d = buf[3];

3216

3217 MD5STEP(F1, a, b, c, d, in[ 0]+0xd76aa478, 7);

3218 MD5STEP(F1, d, a, b, c, in[ 1]+0xe8c7b756, 12);

3219 MD5STEP(F1, c, d, a, b, in[ 2]+0x242070db, 17);

3220 MD5STEP(F1, b, c, d, a, in[ 3]+0xc1bdceee, 22);

3221 MD5STEP(F1, a, b, c, d, in[ 4]+0xf57c0faf, 7);

3222 MD5STEP(F1, d, a, b, c, in[ 5]+0x4787c62a, 12);

3223 MD5STEP(F1, c, d, a, b, in[ 6]+0xa8304613, 17);

3224 MD5STEP(F1, b, c, d, a, in[ 7]+0xfd469501, 22);

3225 MD5STEP(F1, a, b, c, d, in[ 8]+0x698098d8, 7);

3226 MD5STEP(F1, d, a, b, c, in[ 9]+0x8b44f7af, 12);

3227 MD5STEP(F1, c, d, a, b, in[10]+0xffff5bb1, 17);

3228 MD5STEP(F1, b, c, d, a, in[11]+0x895cd7be, 22);

3229 MD5STEP(F1, a, b, c, d, in[12]+0x6b901122, 7);

3230 MD5STEP(F1, d, a, b, c, in[13]+0xfd987193, 12);

3231 MD5STEP(F1, c, d, a, b, in[14]+0xa679438e, 17);

3232 MD5STEP(F1, b, c, d, a, in[15]+0x49b40821, 22);

3233

3234 MD5STEP(F2, a, b, c, d, in[ 1]+0xf61e2562, 5);

3235 MD5STEP(F2, d, a, b, c, in[ 6]+0xc040b340, 9);

3236 MD5STEP(F2, c, d, a, b, in[11]+0x265e5a51, 14);

3237 MD5STEP(F2, b, c, d, a, in[ 0]+0xe9b6c7aa, 20);

3238 MD5STEP(F2, a, b, c, d, in[ 5]+0xd62f105d, 5);

3239 MD5STEP(F2, d, a, b, c, in[10]+0x02441453, 9);

3240 MD5STEP(F2, c, d, a, b, in[15]+0xd8a1e681, 14);

3241 MD5STEP(F2, b, c, d, a, in[ 4]+0xe7d3fbc8, 20);

3242 MD5STEP(F2, a, b, c, d, in[ 9]+0x21e1cde6, 5);

3243 MD5STEP(F2, d, a, b, c, in[14]+0xc33707d6, 9);

3244 MD5STEP(F2, c, d, a, b, in[ 3]+0xf4d50d87, 14);

3245 MD5STEP(F2, b, c, d, a, in[ 8]+0x455a14ed, 20);

3246 MD5STEP(F2, a, b, c, d, in[13]+0xa9e3e905, 5);

3247 MD5STEP(F2, d, a, b, c, in[ 2]+0xfcefa3f8, 9);

3248 MD5STEP(F2, c, d, a, b, in[ 7]+0x676f02d9, 14);

3249 MD5STEP(F2, b, c, d, a, in[12]+0x8d2a4c8a, 20);

3250

3251 MD5STEP(F3, a, b, c, d, in[ 5]+0xfffa3942, 4);

3252 MD5STEP(F3, d, a, b, c, in[ 8]+0x8771f681, 11);

3253 MD5STEP(F3, c, d, a, b, in[11]+0x6d9d6122, 16);

3254 MD5STEP(F3, b, c, d, a, in[14]+0xfde5380c, 23);

3255 MD5STEP(F3, a, b, c, d, in[ 1]+0xa4beea44, 4);

3256 MD5STEP(F3, d, a, b, c, in[ 4]+0x4bdecfa9, 11);

3257 MD5STEP(F3, c, d, a, b, in[ 7]+0xf6bb4b60, 16);

3258 MD5STEP(F3, b, c, d, a, in[10]+0xbebfbc70, 23);

3259 MD5STEP(F3, a, b, c, d, in[13]+0x289b7ec6, 4);

3260 MD5STEP(F3, d, a, b, c, in[ 0]+0xeaa127fa, 11);

3261 MD5STEP(F3, c, d, a, b, in[ 3]+0xd4ef3085, 16);

3262 MD5STEP(F3, b, c, d, a, in[ 6]+0x04881d05, 23);

3263 MD5STEP(F3, a, b, c, d, in[ 9]+0xd9d4d039, 4);

3264 MD5STEP(F3, d, a, b, c, in[12]+0xe6db99e5, 11);

3265 MD5STEP(F3, c, d, a, b, in[15]+0x1fa27cf8, 16);

3266 MD5STEP(F3, b, c, d, a, in[ 2]+0xc4ac5665, 23);

3267

3268 MD5STEP(F4, a, b, c, d, in[ 0]+0xf4292244, 6);

3269 MD5STEP(F4, d, a, b, c, in[ 7]+0x432aff97, 10);

3270 MD5STEP(F4, c, d, a, b, in[14]+0xab9423a7, 15);

3271 MD5STEP(F4, b, c, d, a, in[ 5]+0xfc93a039, 21);

3272 MD5STEP(F4, a, b, c, d, in[12]+0x655b59c3, 6);

3273 MD5STEP(F4, d, a, b, c, in[ 3]+0x8f0ccc92, 10);

3274 MD5STEP(F4, c, d, a, b, in[10]+0xffeff47d, 15);

3275 MD5STEP(F4, b, c, d, a, in[ 1]+0x85845dd1, 21);

3276 MD5STEP(F4, a, b, c, d, in[ 8]+0x6fa87e4f, 6);

3277 MD5STEP(F4, d, a, b, c, in[15]+0xfe2ce6e0, 10);

3278 MD5STEP(F4, c, d, a, b, in[ 6]+0xa3014314, 15);

3279 MD5STEP(F4, b, c, d, a, in[13]+0x4e0811a1, 21);

3280 MD5STEP(F4, a, b, c, d, in[ 4]+0xf7537e82, 6);

3281 MD5STEP(F4, d, a, b, c, in[11]+0xbd3af235, 10);

3282 MD5STEP(F4, c, d, a, b, in[ 2]+0x2ad7d2bb, 15);

3283 MD5STEP(F4, b, c, d, a, in[ 9]+0xeb86d391, 21);

3284

3285 buf[0] += a;

3286 buf[1] += b;

3287 buf[2] += c;

3288 buf[3] += d;

3289 }

3290

3291 /*

3292 * Start MD5 accumulation. Set bit count to 0 and buffer to mysterious

3293 * initialization constants.

3294 */

3295 static void MD5Init(MD5Context *ctx){

3296 ctx->isInit = 1;

3297 ctx->buf[0] = 0x67452301;

3298 ctx->buf[1] = 0xefcdab89;

3299 ctx->buf[2] = 0x98badcfe;

3300 ctx->buf[3] = 0x10325476;

3301 ctx->bits[0] = 0;

3302 ctx->bits[1] = 0;

3303 }

3304

3305 /*

3306 * Update context to reflect the concatenation of another buffer full

3307 * of bytes.

3308 */

3309 static

3310 void MD5Update(MD5Context ctx, const unsigned char buf, unsigned int len){

3311 uint32 t;

3312

3313 /* Update bitcount */

3314

3315 t = ctx->bits[0];

3316 if ((ctx->bits[0] = t + ((uint32)len << 3)) < t)

3317 ctx->bits[1]++; /* Carry from low to high */

3318 ctx->bits[1] += len >> 29;

3319

3320 t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */

3321

3322 /* Handle any leading odd-sized chunks */

3323

3324 if ( t ) {

3325 unsigned char p = (unsigned char )ctx->in + t;

3326

3327 t = 64-t;

3328 if (len < t) {

3329 memcpy(p, buf, len);

3330 return;

3331 }

3332 memcpy(p, buf, t);

3333 byteReverse(ctx->in, 16);

3334 MD5Transform(ctx->buf, (uint32 *)ctx->in);

3335 buf += t;

3336 len -= t;

3337 }

3338

3339 /* Process data in 64-byte chunks */

3340

3341 while (len >= 64) {

3342 memcpy(ctx->in, buf, 64);

3343 byteReverse(ctx->in, 16);

3344 MD5Transform(ctx->buf, (uint32 *)ctx->in);

3345 buf += 64;

3346 len -= 64;

3347 }

3348

3349 /* Handle any remaining bytes of data. */

3350

3351 memcpy(ctx->in, buf, len);

3352 }

3353

3354 /*

3355 * Final wrapup - pad to 64-byte boundary with the bit pattern

3356 * 1 0* (64-bit count of bits processed, MSB-first)

3357 */

3358 static void MD5Final(unsigned char digest[16], MD5Context *ctx){

3359 unsigned count;

3360 unsigned char *p;

3361

3362 /* Compute number of bytes mod 64 */

3363 count = (ctx->bits[0] >> 3) & 0x3F;

3364

3365 /* Set the first char of padding to 0x80. This is safe since there is

3366 always at least one byte free */

3367 p = ctx->in + count;

3368 *p++ = 0x80;

3369

3370 /* Bytes of padding needed to make 64 bytes */

3371 count = 64 - 1 - count;

3372

3373 /* Pad out to 56 mod 64 */

3374 if (count < 8) {

3375 /* Two lots of padding: Pad the first block to 64 bytes */

3376 memset(p, 0, count);

3377 byteReverse(ctx->in, 16);

3378 MD5Transform(ctx->buf, (uint32 *)ctx->in);

3379

3380 /* Now fill the next block with 56 bytes */

3381 memset(ctx->in, 0, 56);

3382 } else {

3383 /* Pad block to 56 bytes */

3384 memset(p, 0, count-8);

3385 }

3386 byteReverse(ctx->in, 14);

3387

3388 /* Append length in bits and transform */

3389 memcpy(ctx->in + 14*4, ctx->bits, 8);

3390

3391 MD5Transform(ctx->buf, (uint32 *)ctx->in);

3392 byteReverse((unsigned char *)ctx->buf, 4);

3393 memcpy(digest, ctx->buf, 16);

3394 }

3395

3396 /*

3397 ** Convert a 128-bit MD5 digest into a 32-digit base-16 number.

3398 */

3399 static void MD5DigestToBase16(unsigned char digest, char zBuf){

3400 static char const zEncode[] = "0123456789abcdef";

3401 int i, j;

3402

3403 for(j=i=0; i<16; i++){

3404 int a = digest[i];

3405 zBuf[j++] = zEncode[(a>>4)&0xf];

3406 zBuf[j++] = zEncode[a & 0xf];

3407 }

3408 zBuf[j] = 0;

3409 }

3410

3411

3412 /*

3413 ** Convert a 128-bit MD5 digest into sequency of eight 5-digit integers

3414 ** each representing 16 bits of the digest and separated from each

3415 ** other by a "-" character.

3416 */

3417 static void MD5DigestToBase10x8(unsigned char digest[16], char zDigest[50]){

3418 int i, j;

3419 unsigned int x;

3420 for(i=j=0; i<16; i+=2){

3421 x = digest[i]*256 + digest[i+1];

3422 if( i>0 ) zDigest[j++] = '-';

3423 sprintf(&zDigest[j], "%05u", x);

3424 j += 5;

3425 }

3426 zDigest[j] = 0;

3427 }

3428

3429 /*

3430 ** A TCL command for md5. The argument is the text to be hashed. The

3431 ** Result is the hash in base64.

3432 */

3433 static int md5_cmd(voidcd, Tcl_Interp interp, int argc, const char **argv){

3434 MD5Context ctx;

3435 unsigned char digest[16];

3436 char zBuf[50];

3437 void (converter)(unsigned char, char*);

3438

3439 if( argc!=2 ){

3440 Tcl_AppendResult(interp,"wrong # args: should be \"", argv[0],

3441 " TEXT\"", (char*)0);

3442 return TCL_ERROR;

3443 }

3444 MD5Init(&ctx);

3445 MD5Update(&ctx, (unsigned char*)argv[1], (unsigned)strlen(argv[1]));

3446 MD5Final(digest, &ctx);

3447 converter = (void()(unsigned char,char*))cd;

3448 converter(digest, zBuf);

3449 Tcl_AppendResult(interp, zBuf, (char*)0);

3450 return TCL_OK;

3451 }

3452

3453 /*

3454 ** A TCL command to take the md5 hash of a file. The argument is the

3455 ** name of the file.

3456 */

3457 static int md5file_cmd(voidcd, Tcl_Interpinterp, int argc, const char **argv){

3458 FILE *in;

3459 MD5Context ctx;

3460 void (converter)(unsigned char, char*);

3461 unsigned char digest[16];

3462 char zBuf[10240];

3463

3464 if( argc!=2 ){

3465 Tcl_AppendResult(interp,"wrong # args: should be \"", argv[0],

3466 " FILENAME\"", (char*)0);

3467 return TCL_ERROR;

3468 }

3469 in = fopen(argv[1],"rb");

3470 if( in==0 ){

3471 Tcl_AppendResult(interp,"unable to open file \"", argv[1],

3472 "\" for reading", (char*)0);

3473 return TCL_ERROR;

3474 }

3475 MD5Init(&ctx);

3476 for(;;){

3477 int n;

3478 n = (int)fread(zBuf, 1, sizeof(zBuf), in);

3479 if( n<=0 ) break;

3480 MD5Update(&ctx, (unsigned char*)zBuf, (unsigned)n);

3481 }

3482 fclose(in);

3483 MD5Final(digest, &ctx);

3484 converter = (void()(unsigned char,char*))cd;

3485 converter(digest, zBuf);

3486 Tcl_AppendResult(interp, zBuf, (char*)0);

3487 return TCL_OK;

3488 }

3489

3490 /*

3491 ** Register the four new TCL commands for generating MD5 checksums

3492 ** with the TCL interpreter.

3493 */

3494 int Md5_Init(Tcl_Interp *interp){

3495 Tcl_CreateCommand(interp, "md5", (Tcl_CmdProc*)md5_cmd,

3496 MD5DigestToBase16, 0);

3497 Tcl_CreateCommand(interp, "md5-10x8", (Tcl_CmdProc*)md5_cmd,

3498 MD5DigestToBase10x8, 0);

3499 Tcl_CreateCommand(interp, "md5file", (Tcl_CmdProc*)md5file_cmd,

3500 MD5DigestToBase16, 0);

3501 Tcl_CreateCommand(interp, "md5file-10x8", (Tcl_CmdProc*)md5file_cmd,

3502 MD5DigestToBase10x8, 0);

3503 return TCL_OK;

3504 }

3505 #endif /* defined(SQLITE_TEST) \|\| defined(SQLITE_TCLMD5) */

3506

3507 #if defined(SQLITE_TEST)

3508 /*

3509 ** During testing, the special md5sum() aggregate function is available.

3510 ** inside SQLite. The following routines implement that function.

3511 */

3512 static void md5step(sqlite3_context context, int argc, sqlite3_value *argv){

3513 MD5Context *p;

3514 int i;

3515 if( argc<1 ) return;

3516 p = sqlite3_aggregate_context(context, sizeof(*p));

3517 if( p==0 ) return;

3518 if( !p->isInit ){

3519 MD5Init(p);

3520 }

3521 for(i=0; i<argc; i++){

3522 const char zData = (char)sqlite3_value_text(argv[i]);

3523 if( zData ){

3524 MD5Update(p, (unsigned char*)zData, (int)strlen(zData));

3525 }

3526 }

3527 }

3528 static void md5finalize(sqlite3_context *context){

3529 MD5Context *p;

3530 unsigned char digest[16];

3531 char zBuf[33];

3532 p = sqlite3_aggregate_context(context, sizeof(*p));

3533 MD5Final(digest,p);

3534 MD5DigestToBase16(digest, zBuf);

3535 sqlite3_result_text(context, zBuf, -1, SQLITE_TRANSIENT);

3536 }

3537 int Md5_Register(sqlite3 *db){

3538 int rc = sqlite3_create_function(db, "md5sum", -1, SQLITE_UTF8, 0, 0,

3539 md5step, md5finalize);

3540 sqlite3_overload_function(db, "md5sum", -1); /* To exercise this API */

3541 return rc;

3542 }

3543 #endif /* defined(SQLITE_TEST) */

3544

3545

3546 /*

3547 ** If the macro TCLSH is one, then put in code this for the

3548 ** "main" routine that will initialize Tcl and take input from

3549 ** standard input, or if a file is named on the command line

3550 ** the TCL interpreter reads and evaluates that file.

3551 */

3552 #if TCLSH==1

3553 static const char *tclsh_main_loop(void){

3554 static const char zMainloop[] =

3555 "set line {}\n"

3556 "while {![eof stdin]} {\n"

3557 "if {$line!=\"\"} {\n"

3558 "puts -nonewline \"> \"\n"

3559 "} else {\n"

3560 "puts -nonewline \"% \"\n"

3561 "}\n"

3562 "flush stdout\n"

3563 "append line [gets stdin]\n"

3564 "if {[info complete $line]} {\n"

3565 "if {[catch {uplevel #0 $line} result]} {\n"

3566 "puts stderr \"Error: $result\"\n"

3567 "} elseif {$result!=\"\"} {\n"

3568 "puts $result\n"

3569 "}\n"

3570 "set line {}\n"

3571 "} else {\n"

3572 "append line \\n\n"

3573 "}\n"

3574 "}\n"

3575 ;

3576 return zMainloop;

3577 }

3578 #endif

3579 #if TCLSH==2

3580 static const char *tclsh_main_loop(void);

3581 #endif

3582

3583 #ifdef SQLITE_TEST

3584 static void init_all(Tcl_Interp *);

3585 static int init_all_cmd(

3586 ClientData cd,

3587 Tcl_Interp *interp,

3588 int objc,

3589 Tcl_Obj *CONST objv[]

3590 ){

3591

3592 Tcl_Interp *slave;

3593 if( objc!=2 ){

3594 Tcl_WrongNumArgs(interp, 1, objv, "SLAVE");

3595 return TCL_ERROR;

3596 }

3597

3598 slave = Tcl_GetSlave(interp, Tcl_GetString(objv[1]));

3599 if( !slave ){

3600 return TCL_ERROR;

3601 }

3602

3603 init_all(slave);

3604 return TCL_OK;

3605 }

3606

3607 /*

3608 ** Tclcmd: db_use_legacy_prepare DB BOOLEAN

3609 **

3610 ** The first argument to this command must be a database command created by

3611 ** [sqlite3]. If the second argument is true, then the handle is configured

3612 ** to use the sqlite3_prepare_v2() function to prepare statements. If it

3613 ** is false, sqlite3_prepare().

3614 */

3615 static int db_use_legacy_prepare_cmd(

3616 ClientData cd,

3617 Tcl_Interp *interp,

3618 int objc,

3619 Tcl_Obj *CONST objv[]

3620 ){

3621 Tcl_CmdInfo cmdInfo;

3622 SqliteDb *pDb;

3623 int bPrepare;

3624

3625 if( objc!=3 ){

3626 Tcl_WrongNumArgs(interp, 1, objv, "DB BOOLEAN");

3627 return TCL_ERROR;

3628 }

3629

3630 if( !Tcl_GetCommandInfo(interp, Tcl_GetString(objv[1]), &cmdInfo) ){

3631 Tcl_AppendResult(interp, "no such db: ", Tcl_GetString(objv[1]), (char*)0);

3632 return TCL_ERROR;

3633 }

3634 pDb = (SqliteDb*)cmdInfo.objClientData;

3635 if( Tcl_GetBooleanFromObj(interp, objv[2], &bPrepare) ){

3636 return TCL_ERROR;

3637 }

3638

3639 pDb->bLegacyPrepare = bPrepare;

3640

3641 Tcl_ResetResult(interp);

3642 return TCL_OK;

3643 }

3644 #endif

3645

3646 /*

3647 ** Configure the interpreter passed as the first argument to have access

3648 ** to the commands and linked variables that make up:

3649 **

3650 ** * the [sqlite3] extension itself,

3651 **

3652 ** * If SQLITE_TCLMD5 or SQLITE_TEST is defined, the Md5 commands, and

3653 **

3654 ** * If SQLITE_TEST is set, the various test interfaces used by the Tcl

3655 ** test suite.

3656 */

3657 static void init_all(Tcl_Interp *interp){

3658 Sqlite3_Init(interp);

3659

3660 #if defined(SQLITE_TEST) \|\| defined(SQLITE_TCLMD5)

3661 Md5_Init(interp);

3662 #endif

3663

3664 /* Install the [register_dbstat_vtab] command to access the implementation

3665 ** of virtual table dbstat (source file test_stat.c). This command is

3666 ** required for testfixture and sqlite3_analyzer, but not by the production

3667 ** Tcl extension. */

3668 #if defined(SQLITE_TEST) \|\| TCLSH==2

3669 {

3670 extern int SqlitetestStat_Init(Tcl_Interp*);

3671 SqlitetestStat_Init(interp);

3672 }

3673 #endif

3674

3675 #ifdef SQLITE_TEST

3676 {

3677 extern int Sqliteconfig_Init(Tcl_Interp*);

3678 extern int Sqlitetest1_Init(Tcl_Interp*);

3679 extern int Sqlitetest2_Init(Tcl_Interp*);

3680 extern int Sqlitetest3_Init(Tcl_Interp*);

3681 extern int Sqlitetest4_Init(Tcl_Interp*);

3682 extern int Sqlitetest5_Init(Tcl_Interp*);

3683 extern int Sqlitetest6_Init(Tcl_Interp*);

3684 extern int Sqlitetest7_Init(Tcl_Interp*);

3685 extern int Sqlitetest8_Init(Tcl_Interp*);

3686 extern int Sqlitetest9_Init(Tcl_Interp*);

3687 extern int Sqlitetestasync_Init(Tcl_Interp*);

3688 extern int Sqlitetest_autoext_Init(Tcl_Interp*);

3689 extern int Sqlitetest_demovfs_Init(Tcl_Interp *);

3690 extern int Sqlitetest_func_Init(Tcl_Interp*);

3691 extern int Sqlitetest_hexio_Init(Tcl_Interp*);

3692 extern int Sqlitetest_init_Init(Tcl_Interp*);

3693 extern int Sqlitetest_malloc_Init(Tcl_Interp*);

3694 extern int Sqlitetest_mutex_Init(Tcl_Interp*);

3695 extern int Sqlitetestschema_Init(Tcl_Interp*);

3696 extern int Sqlitetestsse_Init(Tcl_Interp*);

3697 extern int Sqlitetesttclvar_Init(Tcl_Interp*);

3698 extern int Sqlitetestfs_Init(Tcl_Interp*);

3699 extern int SqlitetestThread_Init(Tcl_Interp*);

3700 extern int SqlitetestOnefile_Init();

3701 extern int SqlitetestOsinst_Init(Tcl_Interp*);

3702 extern int Sqlitetestbackup_Init(Tcl_Interp*);

3703 extern int Sqlitetestintarray_Init(Tcl_Interp*);

3704 extern int Sqlitetestvfs_Init(Tcl_Interp *);

3705 extern int Sqlitetestrtree_Init(Tcl_Interp*);

3706 extern int Sqlitequota_Init(Tcl_Interp*);

3707 extern int Sqlitemultiplex_Init(Tcl_Interp*);

3708 extern int SqliteSuperlock_Init(Tcl_Interp*);

3709 extern int SqlitetestSyscall_Init(Tcl_Interp*);

3710

3711 #if defined(SQLITE_ENABLE_FTS3) \|\| defined(SQLITE_ENABLE_FTS4)

3712 extern int Sqlitetestfts3_Init(Tcl_Interp *interp);

3713 #endif

3714

3715 #ifdef SQLITE_ENABLE_ZIPVFS

3716 extern int Zipvfs_Init(Tcl_Interp*);

3717 Zipvfs_Init(interp);

3718 #endif

3719

3720 Sqliteconfig_Init(interp);

3721 Sqlitetest1_Init(interp);

3722 Sqlitetest2_Init(interp);

3723 Sqlitetest3_Init(interp);

3724 Sqlitetest4_Init(interp);

3725 Sqlitetest5_Init(interp);

3726 Sqlitetest6_Init(interp);

3727 Sqlitetest7_Init(interp);

3728 Sqlitetest8_Init(interp);

3729 Sqlitetest9_Init(interp);

3730 Sqlitetestasync_Init(interp);

3731 Sqlitetest_autoext_Init(interp);

3732 Sqlitetest_demovfs_Init(interp);

3733 Sqlitetest_func_Init(interp);

3734 Sqlitetest_hexio_Init(interp);

3735 Sqlitetest_init_Init(interp);

3736 Sqlitetest_malloc_Init(interp);

3737 Sqlitetest_mutex_Init(interp);

3738 Sqlitetestschema_Init(interp);

3739 Sqlitetesttclvar_Init(interp);

3740 Sqlitetestfs_Init(interp);

3741 SqlitetestThread_Init(interp);

3742 SqlitetestOnefile_Init(interp);

3743 SqlitetestOsinst_Init(interp);

3744 Sqlitetestbackup_Init(interp);

3745 Sqlitetestintarray_Init(interp);

3746 Sqlitetestvfs_Init(interp);

3747 Sqlitetestrtree_Init(interp);

3748 Sqlitequota_Init(interp);

3749 Sqlitemultiplex_Init(interp);

3750 SqliteSuperlock_Init(interp);

3751 SqlitetestSyscall_Init(interp);

3752

3753 #if defined(SQLITE_ENABLE_FTS3) \|\| defined(SQLITE_ENABLE_FTS4)

3754 Sqlitetestfts3_Init(interp);

3755 #endif

3756

3757 Tcl_CreateObjCommand(

3758 interp, "load_testfixture_extensions", init_all_cmd, 0, 0

3759 );

3760 Tcl_CreateObjCommand(

3761 interp, "db_use_legacy_prepare", db_use_legacy_prepare_cmd, 0, 0

3762 );

3763

3764 #ifdef SQLITE_SSE

3765 Sqlitetestsse_Init(interp);

3766 #endif

3767 }

3768 #endif

3769 }

3770

3771 #define TCLSH_MAIN main /* Needed to fake out mktclapp */

3772 int TCLSH_MAIN(int argc, char **argv){

3773 Tcl_Interp *interp;

3774

3775 #if !defined(_WIN32_WCE)

3776 if( getenv("BREAK") ){

3777 fprintf(stderr,

3778 "attach debugger to process %d and press any key to continue.\n",

3779 GETPID());

3780 fgetc(stdin);

3781 }

3782 #endif

3783

3784 /* Call sqlite3_shutdown() once before doing anything else. This is to

3785 ** test that sqlite3_shutdown() can be safely called by a process before

3786 ** sqlite3_initialize() is. */

3787 sqlite3_shutdown();

3788

3789 Tcl_FindExecutable(argv[0]);

3790 Tcl_SetSystemEncoding(NULL, "utf-8");

3791 interp = Tcl_CreateInterp();

3792

3793 #if TCLSH==2

3794 sqlite3_config(SQLITE_CONFIG_SINGLETHREAD);

3795 #endif

3796

3797 init_all(interp);

3798 if( argc>=2 ){

3799 int i;

3800 char zArgc[32];

3801 sqlite3_snprintf(sizeof(zArgc), zArgc, "%d", argc-(3-TCLSH));

3802 Tcl_SetVar(interp,"argc", zArgc, TCL_GLOBAL_ONLY);

3803 Tcl_SetVar(interp,"argv0",argv[1],TCL_GLOBAL_ONLY);

3804 Tcl_SetVar(interp,"argv", "", TCL_GLOBAL_ONLY);

3805 for(i=3-TCLSH; i<argc; i++){

3806 Tcl_SetVar(interp, "argv", argv[i],

3807 TCL_GLOBAL_ONLY \| TCL_LIST_ELEMENT \| TCL_APPEND_VALUE);

3808 }

3809 if( TCLSH==1 && Tcl_EvalFile(interp, argv[1])!=TCL_OK ){

3810 const char *zInfo = Tcl_GetVar(interp, "errorInfo", TCL_GLOBAL_ONLY);

3811 if( zInfo==0 ) zInfo = Tcl_GetStringResult(interp);

3812 fprintf(stderr,"%s: %s\n", *argv, zInfo);

3813 return 1;

3814 }

3815 }

3816 if( TCLSH==2 \|\| argc<=1 ){

3817 Tcl_GlobalEval(interp, tclsh_main_loop());

3818 }

3819 return 0;

3820 }

3821 #endif /* TCLSH */

OLD	NEW

« no previous file with comments | « third_party/sqlite/sqlite-src-3080704/src/table.c ('k') | third_party/sqlite/sqlite-src-3080704/src/test1.c » ('j') | no next file with comments »