1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sqlite3api/TEST/SRC/test3.c Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1605 @@
1.4 +/*
1.5 +** 2001 September 15
1.6 +**
1.7 +** The author disclaims copyright to this source code. In place of
1.8 +** a legal notice, here is a blessing:
1.9 +**
1.10 +** May you do good and not evil.
1.11 +** May you find forgiveness for yourself and forgive others.
1.12 +** May you share freely, never taking more than you give.
1.13 +**
1.14 +*************************************************************************
1.15 +** Code for testing the btree.c module in SQLite. This code
1.16 +** is not included in the SQLite library. It is used for automated
1.17 +** testing of the SQLite library.
1.18 +**
1.19 +** $Id: test3.c,v 1.101 2008/08/13 19:11:48 drh Exp $
1.20 +*/
1.21 +#include "sqliteInt.h"
1.22 +#include "btreeInt.h"
1.23 +#include "tcl.h"
1.24 +#include <stdlib.h>
1.25 +#include <string.h>
1.26 +
1.27 +/*
1.28 +** Interpret an SQLite error number
1.29 +*/
1.30 +static char *errorName(int rc){
1.31 + char *zName;
1.32 + switch( rc ){
1.33 + case SQLITE_OK: zName = "SQLITE_OK"; break;
1.34 + case SQLITE_ERROR: zName = "SQLITE_ERROR"; break;
1.35 + case SQLITE_PERM: zName = "SQLITE_PERM"; break;
1.36 + case SQLITE_ABORT: zName = "SQLITE_ABORT"; break;
1.37 + case SQLITE_BUSY: zName = "SQLITE_BUSY"; break;
1.38 + case SQLITE_NOMEM: zName = "SQLITE_NOMEM"; break;
1.39 + case SQLITE_READONLY: zName = "SQLITE_READONLY"; break;
1.40 + case SQLITE_INTERRUPT: zName = "SQLITE_INTERRUPT"; break;
1.41 + case SQLITE_IOERR: zName = "SQLITE_IOERR"; break;
1.42 + case SQLITE_CORRUPT: zName = "SQLITE_CORRUPT"; break;
1.43 + case SQLITE_FULL: zName = "SQLITE_FULL"; break;
1.44 + case SQLITE_CANTOPEN: zName = "SQLITE_CANTOPEN"; break;
1.45 + case SQLITE_PROTOCOL: zName = "SQLITE_PROTOCOL"; break;
1.46 + case SQLITE_EMPTY: zName = "SQLITE_EMPTY"; break;
1.47 + case SQLITE_LOCKED: zName = "SQLITE_LOCKED"; break;
1.48 + default: zName = "SQLITE_Unknown"; break;
1.49 + }
1.50 + return zName;
1.51 +}
1.52 +
1.53 +/*
1.54 +** A bogus sqlite3 connection structure for use in the btree
1.55 +** tests.
1.56 +*/
1.57 +static sqlite3 sDb;
1.58 +static int nRefSqlite3 = 0;
1.59 +
1.60 +/*
1.61 +** Usage: btree_open FILENAME NCACHE FLAGS
1.62 +**
1.63 +** Open a new database
1.64 +*/
1.65 +static int btree_open(
1.66 + void *NotUsed,
1.67 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.68 + int argc, /* Number of arguments */
1.69 + const char **argv /* Text of each argument */
1.70 +){
1.71 + Btree *pBt;
1.72 + int rc, nCache, flags;
1.73 + char zBuf[100];
1.74 + if( argc!=4 ){
1.75 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.76 + " FILENAME NCACHE FLAGS\"", 0);
1.77 + return TCL_ERROR;
1.78 + }
1.79 + if( Tcl_GetInt(interp, argv[2], &nCache) ) return TCL_ERROR;
1.80 + if( Tcl_GetInt(interp, argv[3], &flags) ) return TCL_ERROR;
1.81 + nRefSqlite3++;
1.82 + if( nRefSqlite3==1 ){
1.83 + sDb.pVfs = sqlite3_vfs_find(0);
1.84 + sDb.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE);
1.85 + sqlite3_mutex_enter(sDb.mutex);
1.86 + }
1.87 + rc = sqlite3BtreeOpen(argv[1], &sDb, &pBt, flags,
1.88 + SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_MAIN_DB);
1.89 + if( rc!=SQLITE_OK ){
1.90 + Tcl_AppendResult(interp, errorName(rc), 0);
1.91 + return TCL_ERROR;
1.92 + }
1.93 + sqlite3BtreeSetCacheSize(pBt, nCache);
1.94 + sqlite3_snprintf(sizeof(zBuf), zBuf,"%p", pBt);
1.95 + Tcl_AppendResult(interp, zBuf, 0);
1.96 + return TCL_OK;
1.97 +}
1.98 +
1.99 +/*
1.100 +** Usage: btree_close ID
1.101 +**
1.102 +** Close the given database.
1.103 +*/
1.104 +static int btree_close(
1.105 + void *NotUsed,
1.106 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.107 + int argc, /* Number of arguments */
1.108 + const char **argv /* Text of each argument */
1.109 +){
1.110 + Btree *pBt;
1.111 + int rc;
1.112 + if( argc!=2 ){
1.113 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.114 + " ID\"", 0);
1.115 + return TCL_ERROR;
1.116 + }
1.117 + pBt = sqlite3TestTextToPtr(argv[1]);
1.118 + rc = sqlite3BtreeClose(pBt);
1.119 + if( rc!=SQLITE_OK ){
1.120 + Tcl_AppendResult(interp, errorName(rc), 0);
1.121 + return TCL_ERROR;
1.122 + }
1.123 + nRefSqlite3--;
1.124 + if( nRefSqlite3==0 ){
1.125 + sqlite3_mutex_leave(sDb.mutex);
1.126 + sqlite3_mutex_free(sDb.mutex);
1.127 + sDb.mutex = 0;
1.128 + sDb.pVfs = 0;
1.129 + }
1.130 + return TCL_OK;
1.131 +}
1.132 +
1.133 +
1.134 +/*
1.135 +** Usage: btree_begin_transaction ID
1.136 +**
1.137 +** Start a new transaction
1.138 +*/
1.139 +static int btree_begin_transaction(
1.140 + void *NotUsed,
1.141 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.142 + int argc, /* Number of arguments */
1.143 + const char **argv /* Text of each argument */
1.144 +){
1.145 + Btree *pBt;
1.146 + int rc;
1.147 + if( argc!=2 ){
1.148 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.149 + " ID\"", 0);
1.150 + return TCL_ERROR;
1.151 + }
1.152 + pBt = sqlite3TestTextToPtr(argv[1]);
1.153 + sqlite3BtreeEnter(pBt);
1.154 + rc = sqlite3BtreeBeginTrans(pBt, 1);
1.155 + sqlite3BtreeLeave(pBt);
1.156 + if( rc!=SQLITE_OK ){
1.157 + Tcl_AppendResult(interp, errorName(rc), 0);
1.158 + return TCL_ERROR;
1.159 + }
1.160 + return TCL_OK;
1.161 +}
1.162 +
1.163 +/*
1.164 +** Usage: btree_rollback ID
1.165 +**
1.166 +** Rollback changes
1.167 +*/
1.168 +static int btree_rollback(
1.169 + void *NotUsed,
1.170 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.171 + int argc, /* Number of arguments */
1.172 + const char **argv /* Text of each argument */
1.173 +){
1.174 + Btree *pBt;
1.175 + int rc;
1.176 + if( argc!=2 ){
1.177 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.178 + " ID\"", 0);
1.179 + return TCL_ERROR;
1.180 + }
1.181 + pBt = sqlite3TestTextToPtr(argv[1]);
1.182 + sqlite3BtreeEnter(pBt);
1.183 + rc = sqlite3BtreeRollback(pBt);
1.184 + sqlite3BtreeLeave(pBt);
1.185 + if( rc!=SQLITE_OK ){
1.186 + Tcl_AppendResult(interp, errorName(rc), 0);
1.187 + return TCL_ERROR;
1.188 + }
1.189 + return TCL_OK;
1.190 +}
1.191 +
1.192 +/*
1.193 +** Usage: btree_commit ID
1.194 +**
1.195 +** Commit all changes
1.196 +*/
1.197 +static int btree_commit(
1.198 + void *NotUsed,
1.199 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.200 + int argc, /* Number of arguments */
1.201 + const char **argv /* Text of each argument */
1.202 +){
1.203 + Btree *pBt;
1.204 + int rc;
1.205 + if( argc!=2 ){
1.206 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.207 + " ID\"", 0);
1.208 + return TCL_ERROR;
1.209 + }
1.210 + pBt = sqlite3TestTextToPtr(argv[1]);
1.211 + sqlite3BtreeEnter(pBt);
1.212 + rc = sqlite3BtreeCommit(pBt);
1.213 + sqlite3BtreeLeave(pBt);
1.214 + if( rc!=SQLITE_OK ){
1.215 + Tcl_AppendResult(interp, errorName(rc), 0);
1.216 + return TCL_ERROR;
1.217 + }
1.218 + return TCL_OK;
1.219 +}
1.220 +
1.221 +/*
1.222 +** Usage: btree_begin_statement ID
1.223 +**
1.224 +** Start a new statement transaction
1.225 +*/
1.226 +static int btree_begin_statement(
1.227 + void *NotUsed,
1.228 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.229 + int argc, /* Number of arguments */
1.230 + const char **argv /* Text of each argument */
1.231 +){
1.232 + Btree *pBt;
1.233 + int rc;
1.234 + if( argc!=2 ){
1.235 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.236 + " ID\"", 0);
1.237 + return TCL_ERROR;
1.238 + }
1.239 + pBt = sqlite3TestTextToPtr(argv[1]);
1.240 + sqlite3BtreeEnter(pBt);
1.241 + rc = sqlite3BtreeBeginStmt(pBt);
1.242 + sqlite3BtreeLeave(pBt);
1.243 + if( rc!=SQLITE_OK ){
1.244 + Tcl_AppendResult(interp, errorName(rc), 0);
1.245 + return TCL_ERROR;
1.246 + }
1.247 + return TCL_OK;
1.248 +}
1.249 +
1.250 +/*
1.251 +** Usage: btree_rollback_statement ID
1.252 +**
1.253 +** Rollback changes
1.254 +*/
1.255 +static int btree_rollback_statement(
1.256 + void *NotUsed,
1.257 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.258 + int argc, /* Number of arguments */
1.259 + const char **argv /* Text of each argument */
1.260 +){
1.261 + Btree *pBt;
1.262 + int rc;
1.263 + if( argc!=2 ){
1.264 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.265 + " ID\"", 0);
1.266 + return TCL_ERROR;
1.267 + }
1.268 + pBt = sqlite3TestTextToPtr(argv[1]);
1.269 + sqlite3BtreeEnter(pBt);
1.270 + rc = sqlite3BtreeRollbackStmt(pBt);
1.271 + sqlite3BtreeLeave(pBt);
1.272 + if( rc!=SQLITE_OK ){
1.273 + Tcl_AppendResult(interp, errorName(rc), 0);
1.274 + return TCL_ERROR;
1.275 + }
1.276 + return TCL_OK;
1.277 +}
1.278 +
1.279 +/*
1.280 +** Usage: btree_commit_statement ID
1.281 +**
1.282 +** Commit all changes
1.283 +*/
1.284 +static int btree_commit_statement(
1.285 + void *NotUsed,
1.286 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.287 + int argc, /* Number of arguments */
1.288 + const char **argv /* Text of each argument */
1.289 +){
1.290 + Btree *pBt;
1.291 + int rc;
1.292 + if( argc!=2 ){
1.293 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.294 + " ID\"", 0);
1.295 + return TCL_ERROR;
1.296 + }
1.297 + pBt = sqlite3TestTextToPtr(argv[1]);
1.298 + sqlite3BtreeEnter(pBt);
1.299 + rc = sqlite3BtreeCommitStmt(pBt);
1.300 + sqlite3BtreeLeave(pBt);
1.301 + if( rc!=SQLITE_OK ){
1.302 + Tcl_AppendResult(interp, errorName(rc), 0);
1.303 + return TCL_ERROR;
1.304 + }
1.305 + return TCL_OK;
1.306 +}
1.307 +
1.308 +/*
1.309 +** Usage: btree_create_table ID FLAGS
1.310 +**
1.311 +** Create a new table in the database
1.312 +*/
1.313 +static int btree_create_table(
1.314 + void *NotUsed,
1.315 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.316 + int argc, /* Number of arguments */
1.317 + const char **argv /* Text of each argument */
1.318 +){
1.319 + Btree *pBt;
1.320 + int rc, iTable, flags;
1.321 + char zBuf[30];
1.322 + if( argc!=3 ){
1.323 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.324 + " ID FLAGS\"", 0);
1.325 + return TCL_ERROR;
1.326 + }
1.327 + pBt = sqlite3TestTextToPtr(argv[1]);
1.328 + if( Tcl_GetInt(interp, argv[2], &flags) ) return TCL_ERROR;
1.329 + sqlite3BtreeEnter(pBt);
1.330 + rc = sqlite3BtreeCreateTable(pBt, &iTable, flags);
1.331 + sqlite3BtreeLeave(pBt);
1.332 + if( rc!=SQLITE_OK ){
1.333 + Tcl_AppendResult(interp, errorName(rc), 0);
1.334 + return TCL_ERROR;
1.335 + }
1.336 + sqlite3_snprintf(sizeof(zBuf), zBuf, "%d", iTable);
1.337 + Tcl_AppendResult(interp, zBuf, 0);
1.338 + return TCL_OK;
1.339 +}
1.340 +
1.341 +/*
1.342 +** Usage: btree_drop_table ID TABLENUM
1.343 +**
1.344 +** Delete an entire table from the database
1.345 +*/
1.346 +static int btree_drop_table(
1.347 + void *NotUsed,
1.348 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.349 + int argc, /* Number of arguments */
1.350 + const char **argv /* Text of each argument */
1.351 +){
1.352 + Btree *pBt;
1.353 + int iTable;
1.354 + int rc;
1.355 + int notUsed1;
1.356 + if( argc!=3 ){
1.357 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.358 + " ID TABLENUM\"", 0);
1.359 + return TCL_ERROR;
1.360 + }
1.361 + pBt = sqlite3TestTextToPtr(argv[1]);
1.362 + if( Tcl_GetInt(interp, argv[2], &iTable) ) return TCL_ERROR;
1.363 + sqlite3BtreeEnter(pBt);
1.364 + rc = sqlite3BtreeDropTable(pBt, iTable, ¬Used1);
1.365 + sqlite3BtreeLeave(pBt);
1.366 + if( rc!=SQLITE_OK ){
1.367 + Tcl_AppendResult(interp, errorName(rc), 0);
1.368 + return TCL_ERROR;
1.369 + }
1.370 + return TCL_OK;
1.371 +}
1.372 +
1.373 +/*
1.374 +** Usage: btree_clear_table ID TABLENUM
1.375 +**
1.376 +** Remove all entries from the given table but keep the table around.
1.377 +*/
1.378 +static int btree_clear_table(
1.379 + void *NotUsed,
1.380 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.381 + int argc, /* Number of arguments */
1.382 + const char **argv /* Text of each argument */
1.383 +){
1.384 + Btree *pBt;
1.385 + int iTable;
1.386 + int rc;
1.387 + if( argc!=3 ){
1.388 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.389 + " ID TABLENUM\"", 0);
1.390 + return TCL_ERROR;
1.391 + }
1.392 + pBt = sqlite3TestTextToPtr(argv[1]);
1.393 + if( Tcl_GetInt(interp, argv[2], &iTable) ) return TCL_ERROR;
1.394 + sqlite3BtreeEnter(pBt);
1.395 + rc = sqlite3BtreeClearTable(pBt, iTable);
1.396 + sqlite3BtreeLeave(pBt);
1.397 + if( rc!=SQLITE_OK ){
1.398 + Tcl_AppendResult(interp, errorName(rc), 0);
1.399 + return TCL_ERROR;
1.400 + }
1.401 + return TCL_OK;
1.402 +}
1.403 +
1.404 +/*
1.405 +** Usage: btree_get_meta ID
1.406 +**
1.407 +** Return meta data
1.408 +*/
1.409 +static int btree_get_meta(
1.410 + void *NotUsed,
1.411 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.412 + int argc, /* Number of arguments */
1.413 + const char **argv /* Text of each argument */
1.414 +){
1.415 + Btree *pBt;
1.416 + int rc;
1.417 + int i;
1.418 + if( argc!=2 ){
1.419 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.420 + " ID\"", 0);
1.421 + return TCL_ERROR;
1.422 + }
1.423 + pBt = sqlite3TestTextToPtr(argv[1]);
1.424 + for(i=0; i<SQLITE_N_BTREE_META; i++){
1.425 + char zBuf[30];
1.426 + u32 v;
1.427 + sqlite3BtreeEnter(pBt);
1.428 + rc = sqlite3BtreeGetMeta(pBt, i, &v);
1.429 + sqlite3BtreeLeave(pBt);
1.430 + if( rc!=SQLITE_OK ){
1.431 + Tcl_AppendResult(interp, errorName(rc), 0);
1.432 + return TCL_ERROR;
1.433 + }
1.434 + sqlite3_snprintf(sizeof(zBuf), zBuf,"%d",v);
1.435 + Tcl_AppendElement(interp, zBuf);
1.436 + }
1.437 + return TCL_OK;
1.438 +}
1.439 +
1.440 +/*
1.441 +** Usage: btree_update_meta ID METADATA...
1.442 +**
1.443 +** Return meta data
1.444 +*/
1.445 +static int btree_update_meta(
1.446 + void *NotUsed,
1.447 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.448 + int argc, /* Number of arguments */
1.449 + const char **argv /* Text of each argument */
1.450 +){
1.451 + Btree *pBt;
1.452 + int rc;
1.453 + int i;
1.454 + int aMeta[SQLITE_N_BTREE_META];
1.455 +
1.456 + if( argc!=2+SQLITE_N_BTREE_META ){
1.457 + char zBuf[30];
1.458 + sqlite3_snprintf(sizeof(zBuf), zBuf,"%d",SQLITE_N_BTREE_META);
1.459 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.460 + " ID METADATA...\" (METADATA is ", zBuf, " integers)", 0);
1.461 + return TCL_ERROR;
1.462 + }
1.463 + pBt = sqlite3TestTextToPtr(argv[1]);
1.464 + for(i=1; i<SQLITE_N_BTREE_META; i++){
1.465 + if( Tcl_GetInt(interp, argv[i+2], &aMeta[i]) ) return TCL_ERROR;
1.466 + }
1.467 + for(i=1; i<SQLITE_N_BTREE_META; i++){
1.468 + sqlite3BtreeEnter(pBt);
1.469 + rc = sqlite3BtreeUpdateMeta(pBt, i, aMeta[i]);
1.470 + sqlite3BtreeLeave(pBt);
1.471 + if( rc!=SQLITE_OK ){
1.472 + Tcl_AppendResult(interp, errorName(rc), 0);
1.473 + return TCL_ERROR;
1.474 + }
1.475 + }
1.476 + return TCL_OK;
1.477 +}
1.478 +
1.479 +/*
1.480 +** Usage: btree_pager_stats ID
1.481 +**
1.482 +** Returns pager statistics
1.483 +*/
1.484 +static int btree_pager_stats(
1.485 + void *NotUsed,
1.486 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.487 + int argc, /* Number of arguments */
1.488 + const char **argv /* Text of each argument */
1.489 +){
1.490 + Btree *pBt;
1.491 + int i;
1.492 + int *a;
1.493 +
1.494 + if( argc!=2 ){
1.495 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.496 + " ID\"", 0);
1.497 + return TCL_ERROR;
1.498 + }
1.499 + pBt = sqlite3TestTextToPtr(argv[1]);
1.500 +
1.501 + /* Normally in this file, with a b-tree handle opened using the
1.502 + ** [btree_open] command it is safe to call sqlite3BtreeEnter() directly.
1.503 + ** But this function is sometimes called with a btree handle obtained
1.504 + ** from an open SQLite connection (using [btree_from_db]). In this case
1.505 + ** we need to obtain the mutex for the controlling SQLite handle before
1.506 + ** it is safe to call sqlite3BtreeEnter().
1.507 + */
1.508 + sqlite3_mutex_enter(pBt->db->mutex);
1.509 +
1.510 + sqlite3BtreeEnter(pBt);
1.511 + a = sqlite3PagerStats(sqlite3BtreePager(pBt));
1.512 + for(i=0; i<11; i++){
1.513 + static char *zName[] = {
1.514 + "ref", "page", "max", "size", "state", "err",
1.515 + "hit", "miss", "ovfl", "read", "write"
1.516 + };
1.517 + char zBuf[100];
1.518 + Tcl_AppendElement(interp, zName[i]);
1.519 + sqlite3_snprintf(sizeof(zBuf), zBuf,"%d",a[i]);
1.520 + Tcl_AppendElement(interp, zBuf);
1.521 + }
1.522 + sqlite3BtreeLeave(pBt);
1.523 +
1.524 + /* Release the mutex on the SQLite handle that controls this b-tree */
1.525 + sqlite3_mutex_leave(pBt->db->mutex);
1.526 + return TCL_OK;
1.527 +}
1.528 +
1.529 +/*
1.530 +** Usage: btree_integrity_check ID ROOT ...
1.531 +**
1.532 +** Look through every page of the given BTree file to verify correct
1.533 +** formatting and linkage. Return a line of text for each problem found.
1.534 +** Return an empty string if everything worked.
1.535 +*/
1.536 +static int btree_integrity_check(
1.537 + void *NotUsed,
1.538 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.539 + int argc, /* Number of arguments */
1.540 + const char **argv /* Text of each argument */
1.541 +){
1.542 + Btree *pBt;
1.543 + int nRoot;
1.544 + int *aRoot;
1.545 + int i;
1.546 + int nErr;
1.547 + char *zResult;
1.548 +
1.549 + if( argc<3 ){
1.550 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.551 + " ID ROOT ...\"", 0);
1.552 + return TCL_ERROR;
1.553 + }
1.554 + pBt = sqlite3TestTextToPtr(argv[1]);
1.555 + nRoot = argc-2;
1.556 + aRoot = (int*)sqlite3_malloc( sizeof(int)*(argc-2) );
1.557 + for(i=0; i<argc-2; i++){
1.558 + if( Tcl_GetInt(interp, argv[i+2], &aRoot[i]) ) return TCL_ERROR;
1.559 + }
1.560 +#ifndef SQLITE_OMIT_INTEGRITY_CHECK
1.561 + sqlite3BtreeEnter(pBt);
1.562 + zResult = sqlite3BtreeIntegrityCheck(pBt, aRoot, nRoot, 10000, &nErr);
1.563 + sqlite3BtreeLeave(pBt);
1.564 +#else
1.565 + zResult = 0;
1.566 +#endif
1.567 + sqlite3_free((void*)aRoot);
1.568 + if( zResult ){
1.569 + Tcl_AppendResult(interp, zResult, 0);
1.570 + sqlite3_free(zResult);
1.571 + }
1.572 + return TCL_OK;
1.573 +}
1.574 +
1.575 +/*
1.576 +** Usage: btree_cursor_list ID
1.577 +**
1.578 +** Print information about all cursors to standard output for debugging.
1.579 +*/
1.580 +static int btree_cursor_list(
1.581 + void *NotUsed,
1.582 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.583 + int argc, /* Number of arguments */
1.584 + const char **argv /* Text of each argument */
1.585 +){
1.586 + Btree *pBt;
1.587 +
1.588 + if( argc!=2 ){
1.589 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.590 + " ID\"", 0);
1.591 + return TCL_ERROR;
1.592 + }
1.593 + pBt = sqlite3TestTextToPtr(argv[1]);
1.594 + sqlite3BtreeEnter(pBt);
1.595 + sqlite3BtreeCursorList(pBt);
1.596 + sqlite3BtreeLeave(pBt);
1.597 + return SQLITE_OK;
1.598 +}
1.599 +
1.600 +/*
1.601 +** Usage: btree_cursor ID TABLENUM WRITEABLE
1.602 +**
1.603 +** Create a new cursor. Return the ID for the cursor.
1.604 +*/
1.605 +static int btree_cursor(
1.606 + void *NotUsed,
1.607 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.608 + int argc, /* Number of arguments */
1.609 + const char **argv /* Text of each argument */
1.610 +){
1.611 + Btree *pBt;
1.612 + int iTable;
1.613 + BtCursor *pCur;
1.614 + int rc;
1.615 + int wrFlag;
1.616 + char zBuf[30];
1.617 +
1.618 + if( argc!=4 ){
1.619 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.620 + " ID TABLENUM WRITEABLE\"", 0);
1.621 + return TCL_ERROR;
1.622 + }
1.623 + pBt = sqlite3TestTextToPtr(argv[1]);
1.624 + if( Tcl_GetInt(interp, argv[2], &iTable) ) return TCL_ERROR;
1.625 + if( Tcl_GetBoolean(interp, argv[3], &wrFlag) ) return TCL_ERROR;
1.626 + pCur = (BtCursor *)ckalloc(sqlite3BtreeCursorSize());
1.627 + memset(pCur, 0, sqlite3BtreeCursorSize());
1.628 + sqlite3BtreeEnter(pBt);
1.629 + rc = sqlite3BtreeCursor(pBt, iTable, wrFlag, 0, pCur);
1.630 + sqlite3BtreeLeave(pBt);
1.631 + if( rc ){
1.632 + ckfree((char *)pCur);
1.633 + Tcl_AppendResult(interp, errorName(rc), 0);
1.634 + return TCL_ERROR;
1.635 + }
1.636 + sqlite3_snprintf(sizeof(zBuf), zBuf,"%p", pCur);
1.637 + Tcl_AppendResult(interp, zBuf, 0);
1.638 + return SQLITE_OK;
1.639 +}
1.640 +
1.641 +/*
1.642 +** Usage: btree_close_cursor ID
1.643 +**
1.644 +** Close a cursor opened using btree_cursor.
1.645 +*/
1.646 +static int btree_close_cursor(
1.647 + void *NotUsed,
1.648 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.649 + int argc, /* Number of arguments */
1.650 + const char **argv /* Text of each argument */
1.651 +){
1.652 + BtCursor *pCur;
1.653 + Btree *pBt;
1.654 + int rc;
1.655 +
1.656 + if( argc!=2 ){
1.657 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.658 + " ID\"", 0);
1.659 + return TCL_ERROR;
1.660 + }
1.661 + pCur = sqlite3TestTextToPtr(argv[1]);
1.662 + pBt = pCur->pBtree;
1.663 + sqlite3BtreeEnter(pBt);
1.664 + rc = sqlite3BtreeCloseCursor(pCur);
1.665 + sqlite3BtreeLeave(pBt);
1.666 + ckfree((char *)pCur);
1.667 + if( rc ){
1.668 + Tcl_AppendResult(interp, errorName(rc), 0);
1.669 + return TCL_ERROR;
1.670 + }
1.671 + return SQLITE_OK;
1.672 +}
1.673 +
1.674 +/*
1.675 +** Usage: btree_move_to ID KEY
1.676 +**
1.677 +** Move the cursor to the entry with the given key.
1.678 +*/
1.679 +static int btree_move_to(
1.680 + void *NotUsed,
1.681 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.682 + int argc, /* Number of arguments */
1.683 + const char **argv /* Text of each argument */
1.684 +){
1.685 + BtCursor *pCur;
1.686 + int rc;
1.687 + int res;
1.688 + char zBuf[20];
1.689 +
1.690 + if( argc!=3 ){
1.691 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.692 + " ID KEY\"", 0);
1.693 + return TCL_ERROR;
1.694 + }
1.695 + pCur = sqlite3TestTextToPtr(argv[1]);
1.696 + sqlite3BtreeEnter(pCur->pBtree);
1.697 + if( sqlite3BtreeFlags(pCur) & BTREE_INTKEY ){
1.698 + int iKey;
1.699 + if( Tcl_GetInt(interp, argv[2], &iKey) ){
1.700 + sqlite3BtreeLeave(pCur->pBtree);
1.701 + return TCL_ERROR;
1.702 + }
1.703 + rc = sqlite3BtreeMovetoUnpacked(pCur, 0, iKey, 0, &res);
1.704 + }else{
1.705 + rc = sqlite3BtreeMoveto(pCur, argv[2], strlen(argv[2]), 0, &res);
1.706 + }
1.707 + sqlite3BtreeLeave(pCur->pBtree);
1.708 + if( rc ){
1.709 + Tcl_AppendResult(interp, errorName(rc), 0);
1.710 + return TCL_ERROR;
1.711 + }
1.712 + if( res<0 ) res = -1;
1.713 + if( res>0 ) res = 1;
1.714 + sqlite3_snprintf(sizeof(zBuf), zBuf,"%d",res);
1.715 + Tcl_AppendResult(interp, zBuf, 0);
1.716 + return SQLITE_OK;
1.717 +}
1.718 +
1.719 +/*
1.720 +** Usage: btree_delete ID
1.721 +**
1.722 +** Delete the entry that the cursor is pointing to
1.723 +*/
1.724 +static int btree_delete(
1.725 + void *NotUsed,
1.726 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.727 + int argc, /* Number of arguments */
1.728 + const char **argv /* Text of each argument */
1.729 +){
1.730 + BtCursor *pCur;
1.731 + int rc;
1.732 +
1.733 + if( argc!=2 ){
1.734 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.735 + " ID\"", 0);
1.736 + return TCL_ERROR;
1.737 + }
1.738 + pCur = sqlite3TestTextToPtr(argv[1]);
1.739 + sqlite3BtreeEnter(pCur->pBtree);
1.740 + rc = sqlite3BtreeDelete(pCur);
1.741 + sqlite3BtreeLeave(pCur->pBtree);
1.742 + if( rc ){
1.743 + Tcl_AppendResult(interp, errorName(rc), 0);
1.744 + return TCL_ERROR;
1.745 + }
1.746 + return SQLITE_OK;
1.747 +}
1.748 +
1.749 +/*
1.750 +** Usage: btree_insert ID KEY DATA ?NZERO?
1.751 +**
1.752 +** Create a new entry with the given key and data. If an entry already
1.753 +** exists with the same key the old entry is overwritten.
1.754 +*/
1.755 +static int btree_insert(
1.756 + void * clientData,
1.757 + Tcl_Interp *interp,
1.758 + int objc,
1.759 + Tcl_Obj *CONST objv[]
1.760 +){
1.761 + BtCursor *pCur;
1.762 + int rc;
1.763 + int nZero;
1.764 +
1.765 + if( objc!=4 && objc!=5 ){
1.766 + Tcl_WrongNumArgs(interp, 1, objv, "ID KEY DATA ?NZERO?");
1.767 + return TCL_ERROR;
1.768 + }
1.769 + pCur = sqlite3TestTextToPtr(Tcl_GetString(objv[1]));
1.770 + if( objc==5 ){
1.771 + if( Tcl_GetIntFromObj(interp, objv[4], &nZero) ) return TCL_ERROR;
1.772 + }else{
1.773 + nZero = 0;
1.774 + }
1.775 + sqlite3BtreeEnter(pCur->pBtree);
1.776 + if( sqlite3BtreeFlags(pCur) & BTREE_INTKEY ){
1.777 + i64 iKey;
1.778 + int len;
1.779 + unsigned char *pBuf;
1.780 + if( Tcl_GetWideIntFromObj(interp, objv[2], &iKey) ){
1.781 + sqlite3BtreeLeave(pCur->pBtree);
1.782 + return TCL_ERROR;
1.783 + }
1.784 + pBuf = Tcl_GetByteArrayFromObj(objv[3], &len);
1.785 + rc = sqlite3BtreeInsert(pCur, 0, iKey, pBuf, len, nZero, 0);
1.786 + }else{
1.787 + int keylen;
1.788 + int dlen;
1.789 + unsigned char *pKBuf;
1.790 + unsigned char *pDBuf;
1.791 + pKBuf = Tcl_GetByteArrayFromObj(objv[2], &keylen);
1.792 + pDBuf = Tcl_GetByteArrayFromObj(objv[3], &dlen);
1.793 + rc = sqlite3BtreeInsert(pCur, pKBuf, keylen, pDBuf, dlen, nZero, 0);
1.794 + }
1.795 + sqlite3BtreeLeave(pCur->pBtree);
1.796 + if( rc ){
1.797 + Tcl_AppendResult(interp, errorName(rc), 0);
1.798 + return TCL_ERROR;
1.799 + }
1.800 + return SQLITE_OK;
1.801 +}
1.802 +
1.803 +/*
1.804 +** Usage: btree_next ID
1.805 +**
1.806 +** Move the cursor to the next entry in the table. Return 0 on success
1.807 +** or 1 if the cursor was already on the last entry in the table or if
1.808 +** the table is empty.
1.809 +*/
1.810 +static int btree_next(
1.811 + void *NotUsed,
1.812 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.813 + int argc, /* Number of arguments */
1.814 + const char **argv /* Text of each argument */
1.815 +){
1.816 + BtCursor *pCur;
1.817 + int rc;
1.818 + int res = 0;
1.819 + char zBuf[100];
1.820 +
1.821 + if( argc!=2 ){
1.822 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.823 + " ID\"", 0);
1.824 + return TCL_ERROR;
1.825 + }
1.826 + pCur = sqlite3TestTextToPtr(argv[1]);
1.827 + sqlite3BtreeEnter(pCur->pBtree);
1.828 + rc = sqlite3BtreeNext(pCur, &res);
1.829 + sqlite3BtreeLeave(pCur->pBtree);
1.830 + if( rc ){
1.831 + Tcl_AppendResult(interp, errorName(rc), 0);
1.832 + return TCL_ERROR;
1.833 + }
1.834 + sqlite3_snprintf(sizeof(zBuf),zBuf,"%d",res);
1.835 + Tcl_AppendResult(interp, zBuf, 0);
1.836 + return SQLITE_OK;
1.837 +}
1.838 +
1.839 +/*
1.840 +** Usage: btree_prev ID
1.841 +**
1.842 +** Move the cursor to the previous entry in the table. Return 0 on
1.843 +** success and 1 if the cursor was already on the first entry in
1.844 +** the table or if the table was empty.
1.845 +*/
1.846 +static int btree_prev(
1.847 + void *NotUsed,
1.848 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.849 + int argc, /* Number of arguments */
1.850 + const char **argv /* Text of each argument */
1.851 +){
1.852 + BtCursor *pCur;
1.853 + int rc;
1.854 + int res = 0;
1.855 + char zBuf[100];
1.856 +
1.857 + if( argc!=2 ){
1.858 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.859 + " ID\"", 0);
1.860 + return TCL_ERROR;
1.861 + }
1.862 + pCur = sqlite3TestTextToPtr(argv[1]);
1.863 + sqlite3BtreeEnter(pCur->pBtree);
1.864 + rc = sqlite3BtreePrevious(pCur, &res);
1.865 + sqlite3BtreeLeave(pCur->pBtree);
1.866 + if( rc ){
1.867 + Tcl_AppendResult(interp, errorName(rc), 0);
1.868 + return TCL_ERROR;
1.869 + }
1.870 + sqlite3_snprintf(sizeof(zBuf),zBuf,"%d",res);
1.871 + Tcl_AppendResult(interp, zBuf, 0);
1.872 + return SQLITE_OK;
1.873 +}
1.874 +
1.875 +/*
1.876 +** Usage: btree_first ID
1.877 +**
1.878 +** Move the cursor to the first entry in the table. Return 0 if the
1.879 +** cursor was left point to something and 1 if the table is empty.
1.880 +*/
1.881 +static int btree_first(
1.882 + void *NotUsed,
1.883 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.884 + int argc, /* Number of arguments */
1.885 + const char **argv /* Text of each argument */
1.886 +){
1.887 + BtCursor *pCur;
1.888 + int rc;
1.889 + int res = 0;
1.890 + char zBuf[100];
1.891 +
1.892 + if( argc!=2 ){
1.893 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.894 + " ID\"", 0);
1.895 + return TCL_ERROR;
1.896 + }
1.897 + pCur = sqlite3TestTextToPtr(argv[1]);
1.898 + sqlite3BtreeEnter(pCur->pBtree);
1.899 + rc = sqlite3BtreeFirst(pCur, &res);
1.900 + sqlite3BtreeLeave(pCur->pBtree);
1.901 + if( rc ){
1.902 + Tcl_AppendResult(interp, errorName(rc), 0);
1.903 + return TCL_ERROR;
1.904 + }
1.905 + sqlite3_snprintf(sizeof(zBuf),zBuf,"%d",res);
1.906 + Tcl_AppendResult(interp, zBuf, 0);
1.907 + return SQLITE_OK;
1.908 +}
1.909 +
1.910 +/*
1.911 +** Usage: btree_last ID
1.912 +**
1.913 +** Move the cursor to the last entry in the table. Return 0 if the
1.914 +** cursor was left point to something and 1 if the table is empty.
1.915 +*/
1.916 +static int btree_last(
1.917 + void *NotUsed,
1.918 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.919 + int argc, /* Number of arguments */
1.920 + const char **argv /* Text of each argument */
1.921 +){
1.922 + BtCursor *pCur;
1.923 + int rc;
1.924 + int res = 0;
1.925 + char zBuf[100];
1.926 +
1.927 + if( argc!=2 ){
1.928 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.929 + " ID\"", 0);
1.930 + return TCL_ERROR;
1.931 + }
1.932 + pCur = sqlite3TestTextToPtr(argv[1]);
1.933 + sqlite3BtreeEnter(pCur->pBtree);
1.934 + rc = sqlite3BtreeLast(pCur, &res);
1.935 + sqlite3BtreeLeave(pCur->pBtree);
1.936 + if( rc ){
1.937 + Tcl_AppendResult(interp, errorName(rc), 0);
1.938 + return TCL_ERROR;
1.939 + }
1.940 + sqlite3_snprintf(sizeof(zBuf),zBuf,"%d",res);
1.941 + Tcl_AppendResult(interp, zBuf, 0);
1.942 + return SQLITE_OK;
1.943 +}
1.944 +
1.945 +/*
1.946 +** Usage: btree_eof ID
1.947 +**
1.948 +** Return TRUE if the given cursor is not pointing at a valid entry.
1.949 +** Return FALSE if the cursor does point to a valid entry.
1.950 +*/
1.951 +static int btree_eof(
1.952 + void *NotUsed,
1.953 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.954 + int argc, /* Number of arguments */
1.955 + const char **argv /* Text of each argument */
1.956 +){
1.957 + BtCursor *pCur;
1.958 + int rc;
1.959 + char zBuf[50];
1.960 +
1.961 + if( argc!=2 ){
1.962 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.963 + " ID\"", 0);
1.964 + return TCL_ERROR;
1.965 + }
1.966 + pCur = sqlite3TestTextToPtr(argv[1]);
1.967 + sqlite3BtreeEnter(pCur->pBtree);
1.968 + rc = sqlite3BtreeEof(pCur);
1.969 + sqlite3BtreeLeave(pCur->pBtree);
1.970 + sqlite3_snprintf(sizeof(zBuf),zBuf, "%d", rc);
1.971 + Tcl_AppendResult(interp, zBuf, 0);
1.972 + return SQLITE_OK;
1.973 +}
1.974 +
1.975 +/*
1.976 +** Usage: btree_keysize ID
1.977 +**
1.978 +** Return the number of bytes of key. For an INTKEY table, this
1.979 +** returns the key itself.
1.980 +*/
1.981 +static int btree_keysize(
1.982 + void *NotUsed,
1.983 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.984 + int argc, /* Number of arguments */
1.985 + const char **argv /* Text of each argument */
1.986 +){
1.987 + BtCursor *pCur;
1.988 + u64 n;
1.989 + char zBuf[50];
1.990 +
1.991 + if( argc!=2 ){
1.992 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.993 + " ID\"", 0);
1.994 + return TCL_ERROR;
1.995 + }
1.996 + pCur = sqlite3TestTextToPtr(argv[1]);
1.997 + sqlite3BtreeEnter(pCur->pBtree);
1.998 + sqlite3BtreeKeySize(pCur, (i64*)&n);
1.999 + sqlite3BtreeLeave(pCur->pBtree);
1.1000 + sqlite3_snprintf(sizeof(zBuf),zBuf, "%llu", n);
1.1001 + Tcl_AppendResult(interp, zBuf, 0);
1.1002 + return SQLITE_OK;
1.1003 +}
1.1004 +
1.1005 +/*
1.1006 +** Usage: btree_key ID
1.1007 +**
1.1008 +** Return the key for the entry at which the cursor is pointing.
1.1009 +*/
1.1010 +static int btree_key(
1.1011 + void *NotUsed,
1.1012 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.1013 + int argc, /* Number of arguments */
1.1014 + const char **argv /* Text of each argument */
1.1015 +){
1.1016 + BtCursor *pCur;
1.1017 + int rc;
1.1018 + u64 n;
1.1019 + char *zBuf;
1.1020 +
1.1021 + if( argc!=2 ){
1.1022 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.1023 + " ID\"", 0);
1.1024 + return TCL_ERROR;
1.1025 + }
1.1026 + pCur = sqlite3TestTextToPtr(argv[1]);
1.1027 + sqlite3BtreeEnter(pCur->pBtree);
1.1028 + sqlite3BtreeKeySize(pCur, (i64*)&n);
1.1029 + if( sqlite3BtreeFlags(pCur) & BTREE_INTKEY ){
1.1030 + char zBuf2[60];
1.1031 + sqlite3_snprintf(sizeof(zBuf2),zBuf2, "%llu", n);
1.1032 + Tcl_AppendResult(interp, zBuf2, 0);
1.1033 + }else{
1.1034 + zBuf = sqlite3_malloc( n+1 );
1.1035 + rc = sqlite3BtreeKey(pCur, 0, n, zBuf);
1.1036 + if( rc ){
1.1037 + sqlite3BtreeLeave(pCur->pBtree);
1.1038 + Tcl_AppendResult(interp, errorName(rc), 0);
1.1039 + return TCL_ERROR;
1.1040 + }
1.1041 + zBuf[n] = 0;
1.1042 + Tcl_AppendResult(interp, zBuf, 0);
1.1043 + sqlite3_free(zBuf);
1.1044 + }
1.1045 + sqlite3BtreeLeave(pCur->pBtree);
1.1046 + return SQLITE_OK;
1.1047 +}
1.1048 +
1.1049 +/*
1.1050 +** Usage: btree_data ID ?N?
1.1051 +**
1.1052 +** Return the data for the entry at which the cursor is pointing.
1.1053 +*/
1.1054 +static int btree_data(
1.1055 + void *NotUsed,
1.1056 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.1057 + int argc, /* Number of arguments */
1.1058 + const char **argv /* Text of each argument */
1.1059 +){
1.1060 + BtCursor *pCur;
1.1061 + int rc;
1.1062 + u32 n;
1.1063 + char *zBuf;
1.1064 +
1.1065 + if( argc!=2 && argc!=3 ){
1.1066 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.1067 + " ID\"", 0);
1.1068 + return TCL_ERROR;
1.1069 + }
1.1070 + pCur = sqlite3TestTextToPtr(argv[1]);
1.1071 + sqlite3BtreeEnter(pCur->pBtree);
1.1072 + if( argc==2 ){
1.1073 + sqlite3BtreeDataSize(pCur, &n);
1.1074 + }else{
1.1075 + n = atoi(argv[2]);
1.1076 + }
1.1077 + zBuf = sqlite3_malloc( n+1 );
1.1078 + rc = sqlite3BtreeData(pCur, 0, n, zBuf);
1.1079 + sqlite3BtreeLeave(pCur->pBtree);
1.1080 + if( rc ){
1.1081 + Tcl_AppendResult(interp, errorName(rc), 0);
1.1082 + sqlite3_free(zBuf);
1.1083 + return TCL_ERROR;
1.1084 + }
1.1085 + zBuf[n] = 0;
1.1086 + Tcl_AppendResult(interp, zBuf, 0);
1.1087 + sqlite3_free(zBuf);
1.1088 + return SQLITE_OK;
1.1089 +}
1.1090 +
1.1091 +/*
1.1092 +** Usage: btree_fetch_key ID AMT
1.1093 +**
1.1094 +** Use the sqlite3BtreeKeyFetch() routine to get AMT bytes of the key.
1.1095 +** If sqlite3BtreeKeyFetch() fails, return an empty string.
1.1096 +*/
1.1097 +static int btree_fetch_key(
1.1098 + void *NotUsed,
1.1099 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.1100 + int argc, /* Number of arguments */
1.1101 + const char **argv /* Text of each argument */
1.1102 +){
1.1103 + BtCursor *pCur;
1.1104 + int n;
1.1105 + int amt;
1.1106 + u64 nKey;
1.1107 + const char *zBuf;
1.1108 + char zStatic[1000];
1.1109 +
1.1110 + if( argc!=3 ){
1.1111 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.1112 + " ID AMT\"", 0);
1.1113 + return TCL_ERROR;
1.1114 + }
1.1115 + pCur = sqlite3TestTextToPtr(argv[1]);
1.1116 + if( Tcl_GetInt(interp, argv[2], &n) ) return TCL_ERROR;
1.1117 + sqlite3BtreeEnter(pCur->pBtree);
1.1118 + sqlite3BtreeKeySize(pCur, (i64*)&nKey);
1.1119 + zBuf = sqlite3BtreeKeyFetch(pCur, &amt);
1.1120 + if( zBuf && amt>=n ){
1.1121 + assert( nKey<sizeof(zStatic) );
1.1122 + if( n>0 ) nKey = n;
1.1123 + memcpy(zStatic, zBuf, (int)nKey);
1.1124 + zStatic[nKey] = 0;
1.1125 + Tcl_AppendResult(interp, zStatic, 0);
1.1126 + }
1.1127 + sqlite3BtreeLeave(pCur->pBtree);
1.1128 + return TCL_OK;
1.1129 +}
1.1130 +
1.1131 +/*
1.1132 +** Usage: btree_fetch_data ID AMT
1.1133 +**
1.1134 +** Use the sqlite3BtreeDataFetch() routine to get AMT bytes of the key.
1.1135 +** If sqlite3BtreeDataFetch() fails, return an empty string.
1.1136 +*/
1.1137 +static int btree_fetch_data(
1.1138 + void *NotUsed,
1.1139 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.1140 + int argc, /* Number of arguments */
1.1141 + const char **argv /* Text of each argument */
1.1142 +){
1.1143 + BtCursor *pCur;
1.1144 + int n;
1.1145 + int amt;
1.1146 + u32 nData;
1.1147 + const char *zBuf;
1.1148 + char zStatic[1000];
1.1149 +
1.1150 + if( argc!=3 ){
1.1151 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.1152 + " ID AMT\"", 0);
1.1153 + return TCL_ERROR;
1.1154 + }
1.1155 + pCur = sqlite3TestTextToPtr(argv[1]);
1.1156 + if( Tcl_GetInt(interp, argv[2], &n) ) return TCL_ERROR;
1.1157 + sqlite3BtreeEnter(pCur->pBtree);
1.1158 + sqlite3BtreeDataSize(pCur, &nData);
1.1159 + zBuf = sqlite3BtreeDataFetch(pCur, &amt);
1.1160 + if( zBuf && amt>=n ){
1.1161 + assert( nData<sizeof(zStatic) );
1.1162 + if( n>0 ) nData = n;
1.1163 + memcpy(zStatic, zBuf, (int)nData);
1.1164 + zStatic[nData] = 0;
1.1165 + Tcl_AppendResult(interp, zStatic, 0);
1.1166 + }
1.1167 + sqlite3BtreeLeave(pCur->pBtree);
1.1168 + return TCL_OK;
1.1169 +}
1.1170 +
1.1171 +/*
1.1172 +** Usage: btree_payload_size ID
1.1173 +**
1.1174 +** Return the number of bytes of payload
1.1175 +*/
1.1176 +static int btree_payload_size(
1.1177 + void *NotUsed,
1.1178 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.1179 + int argc, /* Number of arguments */
1.1180 + const char **argv /* Text of each argument */
1.1181 +){
1.1182 + BtCursor *pCur;
1.1183 + int n2;
1.1184 + u64 n1;
1.1185 + char zBuf[50];
1.1186 +
1.1187 + if( argc!=2 ){
1.1188 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.1189 + " ID\"", 0);
1.1190 + return TCL_ERROR;
1.1191 + }
1.1192 + pCur = sqlite3TestTextToPtr(argv[1]);
1.1193 + sqlite3BtreeEnter(pCur->pBtree);
1.1194 + if( sqlite3BtreeFlags(pCur) & BTREE_INTKEY ){
1.1195 + n1 = 0;
1.1196 + }else{
1.1197 + sqlite3BtreeKeySize(pCur, (i64*)&n1);
1.1198 + }
1.1199 + sqlite3BtreeDataSize(pCur, (u32*)&n2);
1.1200 + sqlite3BtreeLeave(pCur->pBtree);
1.1201 + sqlite3_snprintf(sizeof(zBuf),zBuf, "%d", (int)(n1+n2));
1.1202 + Tcl_AppendResult(interp, zBuf, 0);
1.1203 + return SQLITE_OK;
1.1204 +}
1.1205 +
1.1206 +/*
1.1207 +** Usage: btree_cursor_info ID ?UP-CNT?
1.1208 +**
1.1209 +** Return integers containing information about the entry the
1.1210 +** cursor is pointing to:
1.1211 +**
1.1212 +** aResult[0] = The page number
1.1213 +** aResult[1] = The entry number
1.1214 +** aResult[2] = Total number of entries on this page
1.1215 +** aResult[3] = Cell size (local payload + header)
1.1216 +** aResult[4] = Number of free bytes on this page
1.1217 +** aResult[5] = Number of free blocks on the page
1.1218 +** aResult[6] = Total payload size (local + overflow)
1.1219 +** aResult[7] = Header size in bytes
1.1220 +** aResult[8] = Local payload size
1.1221 +** aResult[9] = Parent page number
1.1222 +** aResult[10]= Page number of the first overflow page
1.1223 +*/
1.1224 +static int btree_cursor_info(
1.1225 + void *NotUsed,
1.1226 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.1227 + int argc, /* Number of arguments */
1.1228 + const char **argv /* Text of each argument */
1.1229 +){
1.1230 + BtCursor *pCur;
1.1231 + int rc;
1.1232 + int i, j;
1.1233 + int up;
1.1234 + int aResult[11];
1.1235 + char zBuf[400];
1.1236 +
1.1237 + if( argc!=2 && argc!=3 ){
1.1238 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.1239 + " ID ?UP-CNT?\"", 0);
1.1240 + return TCL_ERROR;
1.1241 + }
1.1242 + pCur = sqlite3TestTextToPtr(argv[1]);
1.1243 + if( argc==3 ){
1.1244 + if( Tcl_GetInt(interp, argv[2], &up) ) return TCL_ERROR;
1.1245 + }else{
1.1246 + up = 0;
1.1247 + }
1.1248 + sqlite3BtreeEnter(pCur->pBtree);
1.1249 + rc = sqlite3BtreeCursorInfo(pCur, aResult, up);
1.1250 + if( rc ){
1.1251 + Tcl_AppendResult(interp, errorName(rc), 0);
1.1252 + sqlite3BtreeLeave(pCur->pBtree);
1.1253 + return TCL_ERROR;
1.1254 + }
1.1255 + j = 0;
1.1256 + for(i=0; i<sizeof(aResult)/sizeof(aResult[0]); i++){
1.1257 + sqlite3_snprintf(40,&zBuf[j]," %d", aResult[i]);
1.1258 + j += strlen(&zBuf[j]);
1.1259 + }
1.1260 + sqlite3BtreeLeave(pCur->pBtree);
1.1261 + Tcl_AppendResult(interp, &zBuf[1], 0);
1.1262 + return SQLITE_OK;
1.1263 +}
1.1264 +
1.1265 +/*
1.1266 +** Copied from btree.c:
1.1267 +*/
1.1268 +static u32 t4Get4byte(unsigned char *p){
1.1269 + return (p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3];
1.1270 +}
1.1271 +
1.1272 +/*
1.1273 +** btree_ovfl_info BTREE CURSOR
1.1274 +**
1.1275 +** Given a cursor, return the sequence of pages number that form the
1.1276 +** overflow pages for the data of the entry that the cursor is point
1.1277 +** to.
1.1278 +*/
1.1279 +static int btree_ovfl_info(
1.1280 + void *NotUsed,
1.1281 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.1282 + int argc, /* Number of arguments */
1.1283 + const char **argv /* Text of each argument */
1.1284 +){
1.1285 + Btree *pBt;
1.1286 + BtCursor *pCur;
1.1287 + Pager *pPager;
1.1288 + int rc;
1.1289 + int n;
1.1290 + int dataSize;
1.1291 + u32 pgno;
1.1292 + void *pPage;
1.1293 + int aResult[11];
1.1294 + char zElem[100];
1.1295 + Tcl_DString str;
1.1296 +
1.1297 + if( argc!=3 ){
1.1298 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.1299 + " BTREE CURSOR", 0);
1.1300 + return TCL_ERROR;
1.1301 + }
1.1302 + pBt = sqlite3TestTextToPtr(argv[1]);
1.1303 + pCur = sqlite3TestTextToPtr(argv[2]);
1.1304 + if( (*(void**)pCur) != (void*)pBt ){
1.1305 + Tcl_AppendResult(interp, "Cursor ", argv[2], " does not belong to btree ",
1.1306 + argv[1], 0);
1.1307 + return TCL_ERROR;
1.1308 + }
1.1309 + sqlite3BtreeEnter(pBt);
1.1310 + pPager = sqlite3BtreePager(pBt);
1.1311 + rc = sqlite3BtreeCursorInfo(pCur, aResult, 0);
1.1312 + if( rc ){
1.1313 + Tcl_AppendResult(interp, errorName(rc), 0);
1.1314 + sqlite3BtreeLeave(pBt);
1.1315 + return TCL_ERROR;
1.1316 + }
1.1317 + dataSize = pBt->pBt->usableSize;
1.1318 + Tcl_DStringInit(&str);
1.1319 + n = aResult[6] - aResult[8];
1.1320 + n = (n + dataSize - 1)/dataSize;
1.1321 + pgno = (u32)aResult[10];
1.1322 + while( pgno && n-- ){
1.1323 + DbPage *pDbPage;
1.1324 + sprintf(zElem, "%d", pgno);
1.1325 + Tcl_DStringAppendElement(&str, zElem);
1.1326 + if( sqlite3PagerGet(pPager, pgno, &pDbPage)!=SQLITE_OK ){
1.1327 + Tcl_DStringFree(&str);
1.1328 + Tcl_AppendResult(interp, "unable to get page ", zElem, 0);
1.1329 + sqlite3BtreeLeave(pBt);
1.1330 + return TCL_ERROR;
1.1331 + }
1.1332 + pPage = sqlite3PagerGetData(pDbPage);
1.1333 + pgno = t4Get4byte((unsigned char*)pPage);
1.1334 + sqlite3PagerUnref(pDbPage);
1.1335 + }
1.1336 + sqlite3BtreeLeave(pBt);
1.1337 + Tcl_DStringResult(interp, &str);
1.1338 + return SQLITE_OK;
1.1339 +}
1.1340 +
1.1341 +/*
1.1342 +** The command is provided for the purpose of setting breakpoints.
1.1343 +** in regression test scripts.
1.1344 +**
1.1345 +** By setting a GDB breakpoint on this procedure and executing the
1.1346 +** btree_breakpoint command in a test script, we can stop GDB at
1.1347 +** the point in the script where the btree_breakpoint command is
1.1348 +** inserted. This is useful for debugging.
1.1349 +*/
1.1350 +static int btree_breakpoint(
1.1351 + void *NotUsed,
1.1352 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.1353 + int argc, /* Number of arguments */
1.1354 + const char **argv /* Text of each argument */
1.1355 +){
1.1356 + return TCL_OK;
1.1357 +}
1.1358 +
1.1359 +/*
1.1360 +** usage: varint_test START MULTIPLIER COUNT INCREMENT
1.1361 +**
1.1362 +** This command tests the putVarint() and getVarint()
1.1363 +** routines, both for accuracy and for speed.
1.1364 +**
1.1365 +** An integer is written using putVarint() and read back with
1.1366 +** getVarint() and varified to be unchanged. This repeats COUNT
1.1367 +** times. The first integer is START*MULTIPLIER. Each iteration
1.1368 +** increases the integer by INCREMENT.
1.1369 +**
1.1370 +** This command returns nothing if it works. It returns an error message
1.1371 +** if something goes wrong.
1.1372 +*/
1.1373 +static int btree_varint_test(
1.1374 + void *NotUsed,
1.1375 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.1376 + int argc, /* Number of arguments */
1.1377 + const char **argv /* Text of each argument */
1.1378 +){
1.1379 + u32 start, mult, count, incr;
1.1380 + u64 in, out;
1.1381 + int n1, n2, i, j;
1.1382 + unsigned char zBuf[100];
1.1383 + if( argc!=5 ){
1.1384 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.1385 + " START MULTIPLIER COUNT INCREMENT\"", 0);
1.1386 + return TCL_ERROR;
1.1387 + }
1.1388 + if( Tcl_GetInt(interp, argv[1], (int*)&start) ) return TCL_ERROR;
1.1389 + if( Tcl_GetInt(interp, argv[2], (int*)&mult) ) return TCL_ERROR;
1.1390 + if( Tcl_GetInt(interp, argv[3], (int*)&count) ) return TCL_ERROR;
1.1391 + if( Tcl_GetInt(interp, argv[4], (int*)&incr) ) return TCL_ERROR;
1.1392 + in = start;
1.1393 + in *= mult;
1.1394 + for(i=0; i<count; i++){
1.1395 + char zErr[200];
1.1396 + n1 = putVarint(zBuf, in);
1.1397 + if( n1>9 || n1<1 ){
1.1398 + sprintf(zErr, "putVarint returned %d - should be between 1 and 9", n1);
1.1399 + Tcl_AppendResult(interp, zErr, 0);
1.1400 + return TCL_ERROR;
1.1401 + }
1.1402 + n2 = getVarint(zBuf, &out);
1.1403 + if( n1!=n2 ){
1.1404 + sprintf(zErr, "putVarint returned %d and getVarint returned %d", n1, n2);
1.1405 + Tcl_AppendResult(interp, zErr, 0);
1.1406 + return TCL_ERROR;
1.1407 + }
1.1408 + if( in!=out ){
1.1409 + sprintf(zErr, "Wrote 0x%016llx and got back 0x%016llx", in, out);
1.1410 + Tcl_AppendResult(interp, zErr, 0);
1.1411 + return TCL_ERROR;
1.1412 + }
1.1413 + if( (in & 0xffffffff)==in ){
1.1414 + u32 out32;
1.1415 + n2 = getVarint32(zBuf, out32);
1.1416 + out = out32;
1.1417 + if( n1!=n2 ){
1.1418 + sprintf(zErr, "putVarint returned %d and GetVarint32 returned %d",
1.1419 + n1, n2);
1.1420 + Tcl_AppendResult(interp, zErr, 0);
1.1421 + return TCL_ERROR;
1.1422 + }
1.1423 + if( in!=out ){
1.1424 + sprintf(zErr, "Wrote 0x%016llx and got back 0x%016llx from GetVarint32",
1.1425 + in, out);
1.1426 + Tcl_AppendResult(interp, zErr, 0);
1.1427 + return TCL_ERROR;
1.1428 + }
1.1429 + }
1.1430 +
1.1431 + /* In order to get realistic timings, run getVarint 19 more times.
1.1432 + ** This is because getVarint is called about 20 times more often
1.1433 + ** than putVarint.
1.1434 + */
1.1435 + for(j=0; j<19; j++){
1.1436 + getVarint(zBuf, &out);
1.1437 + }
1.1438 + in += incr;
1.1439 + }
1.1440 + return TCL_OK;
1.1441 +}
1.1442 +
1.1443 +/*
1.1444 +** usage: btree_from_db DB-HANDLE
1.1445 +**
1.1446 +** This command returns the btree handle for the main database associated
1.1447 +** with the database-handle passed as the argument. Example usage:
1.1448 +**
1.1449 +** sqlite3 db test.db
1.1450 +** set bt [btree_from_db db]
1.1451 +*/
1.1452 +static int btree_from_db(
1.1453 + void *NotUsed,
1.1454 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.1455 + int argc, /* Number of arguments */
1.1456 + const char **argv /* Text of each argument */
1.1457 +){
1.1458 + char zBuf[100];
1.1459 + Tcl_CmdInfo info;
1.1460 + sqlite3 *db;
1.1461 + Btree *pBt;
1.1462 + int iDb = 0;
1.1463 +
1.1464 + if( argc!=2 && argc!=3 ){
1.1465 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.1466 + " DB-HANDLE ?N?\"", 0);
1.1467 + return TCL_ERROR;
1.1468 + }
1.1469 +
1.1470 + if( 1!=Tcl_GetCommandInfo(interp, argv[1], &info) ){
1.1471 + Tcl_AppendResult(interp, "No such db-handle: \"", argv[1], "\"", 0);
1.1472 + return TCL_ERROR;
1.1473 + }
1.1474 + if( argc==3 ){
1.1475 + iDb = atoi(argv[2]);
1.1476 + }
1.1477 +
1.1478 + db = *((sqlite3 **)info.objClientData);
1.1479 + assert( db );
1.1480 +
1.1481 + pBt = db->aDb[iDb].pBt;
1.1482 + sqlite3_snprintf(sizeof(zBuf), zBuf, "%p", pBt);
1.1483 + Tcl_SetResult(interp, zBuf, TCL_VOLATILE);
1.1484 + return TCL_OK;
1.1485 +}
1.1486 +
1.1487 +
1.1488 +/*
1.1489 +** usage: btree_set_cache_size ID NCACHE
1.1490 +**
1.1491 +** Set the size of the cache used by btree $ID.
1.1492 +*/
1.1493 +static int btree_set_cache_size(
1.1494 + void *NotUsed,
1.1495 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.1496 + int argc, /* Number of arguments */
1.1497 + const char **argv /* Text of each argument */
1.1498 +){
1.1499 + int nCache;
1.1500 + Btree *pBt;
1.1501 +
1.1502 + if( argc!=3 ){
1.1503 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.1504 + " BT NCACHE\"", 0);
1.1505 + return TCL_ERROR;
1.1506 + }
1.1507 + pBt = sqlite3TestTextToPtr(argv[1]);
1.1508 + if( Tcl_GetInt(interp, argv[2], &nCache) ) return TCL_ERROR;
1.1509 +
1.1510 + sqlite3_mutex_enter(pBt->db->mutex);
1.1511 + sqlite3BtreeEnter(pBt);
1.1512 + sqlite3BtreeSetCacheSize(pBt, nCache);
1.1513 + sqlite3BtreeLeave(pBt);
1.1514 + sqlite3_mutex_leave(pBt->db->mutex);
1.1515 +
1.1516 + return TCL_OK;
1.1517 +}
1.1518 +
1.1519 +/*
1.1520 +** Usage: btree_ismemdb ID
1.1521 +**
1.1522 +** Return true if the B-Tree is in-memory.
1.1523 +*/
1.1524 +static int btree_ismemdb(
1.1525 + void *NotUsed,
1.1526 + Tcl_Interp *interp, /* The TCL interpreter that invoked this command */
1.1527 + int argc, /* Number of arguments */
1.1528 + const char **argv /* Text of each argument */
1.1529 +){
1.1530 + Btree *pBt;
1.1531 + int res;
1.1532 +
1.1533 + if( argc!=2 ){
1.1534 + Tcl_AppendResult(interp, "wrong # args: should be \"", argv[0],
1.1535 + " ID\"", 0);
1.1536 + return TCL_ERROR;
1.1537 + }
1.1538 + pBt = sqlite3TestTextToPtr(argv[1]);
1.1539 + sqlite3_mutex_enter(pBt->db->mutex);
1.1540 + sqlite3BtreeEnter(pBt);
1.1541 + res = sqlite3PagerIsMemdb(sqlite3BtreePager(pBt));
1.1542 + sqlite3BtreeLeave(pBt);
1.1543 + sqlite3_mutex_leave(pBt->db->mutex);
1.1544 + Tcl_SetObjResult(interp, Tcl_NewBooleanObj(res));
1.1545 + return SQLITE_OK;
1.1546 +}
1.1547 +
1.1548 +
1.1549 +/*
1.1550 +** Register commands with the TCL interpreter.
1.1551 +*/
1.1552 +int Sqlitetest3_Init(Tcl_Interp *interp){
1.1553 + static struct {
1.1554 + char *zName;
1.1555 + Tcl_CmdProc *xProc;
1.1556 + } aCmd[] = {
1.1557 + { "btree_open", (Tcl_CmdProc*)btree_open },
1.1558 + { "btree_close", (Tcl_CmdProc*)btree_close },
1.1559 + { "btree_begin_transaction", (Tcl_CmdProc*)btree_begin_transaction },
1.1560 + { "btree_commit", (Tcl_CmdProc*)btree_commit },
1.1561 + { "btree_rollback", (Tcl_CmdProc*)btree_rollback },
1.1562 + { "btree_create_table", (Tcl_CmdProc*)btree_create_table },
1.1563 + { "btree_drop_table", (Tcl_CmdProc*)btree_drop_table },
1.1564 + { "btree_clear_table", (Tcl_CmdProc*)btree_clear_table },
1.1565 + { "btree_get_meta", (Tcl_CmdProc*)btree_get_meta },
1.1566 + { "btree_update_meta", (Tcl_CmdProc*)btree_update_meta },
1.1567 + { "btree_pager_stats", (Tcl_CmdProc*)btree_pager_stats },
1.1568 + { "btree_cursor", (Tcl_CmdProc*)btree_cursor },
1.1569 + { "btree_close_cursor", (Tcl_CmdProc*)btree_close_cursor },
1.1570 + { "btree_move_to", (Tcl_CmdProc*)btree_move_to },
1.1571 + { "btree_delete", (Tcl_CmdProc*)btree_delete },
1.1572 + { "btree_next", (Tcl_CmdProc*)btree_next },
1.1573 + { "btree_prev", (Tcl_CmdProc*)btree_prev },
1.1574 + { "btree_eof", (Tcl_CmdProc*)btree_eof },
1.1575 + { "btree_keysize", (Tcl_CmdProc*)btree_keysize },
1.1576 + { "btree_key", (Tcl_CmdProc*)btree_key },
1.1577 + { "btree_data", (Tcl_CmdProc*)btree_data },
1.1578 + { "btree_fetch_key", (Tcl_CmdProc*)btree_fetch_key },
1.1579 + { "btree_fetch_data", (Tcl_CmdProc*)btree_fetch_data },
1.1580 + { "btree_payload_size", (Tcl_CmdProc*)btree_payload_size },
1.1581 + { "btree_first", (Tcl_CmdProc*)btree_first },
1.1582 + { "btree_last", (Tcl_CmdProc*)btree_last },
1.1583 + { "btree_integrity_check", (Tcl_CmdProc*)btree_integrity_check },
1.1584 + { "btree_breakpoint", (Tcl_CmdProc*)btree_breakpoint },
1.1585 + { "btree_varint_test", (Tcl_CmdProc*)btree_varint_test },
1.1586 + { "btree_begin_statement", (Tcl_CmdProc*)btree_begin_statement },
1.1587 + { "btree_commit_statement", (Tcl_CmdProc*)btree_commit_statement },
1.1588 + { "btree_rollback_statement", (Tcl_CmdProc*)btree_rollback_statement },
1.1589 + { "btree_from_db", (Tcl_CmdProc*)btree_from_db },
1.1590 + { "btree_set_cache_size", (Tcl_CmdProc*)btree_set_cache_size },
1.1591 + { "btree_cursor_info", (Tcl_CmdProc*)btree_cursor_info },
1.1592 + { "btree_ovfl_info", (Tcl_CmdProc*)btree_ovfl_info },
1.1593 + { "btree_cursor_list", (Tcl_CmdProc*)btree_cursor_list },
1.1594 + { "btree_ismemdb", (Tcl_CmdProc*)btree_ismemdb },
1.1595 + };
1.1596 + int i;
1.1597 +
1.1598 + for(i=0; i<sizeof(aCmd)/sizeof(aCmd[0]); i++){
1.1599 + Tcl_CreateCommand(interp, aCmd[i].zName, aCmd[i].xProc, 0, 0);
1.1600 + }
1.1601 +
1.1602 + /* The btree_insert command is implemented using the tcl 'object'
1.1603 + ** interface, not the string interface like the other commands in this
1.1604 + ** file. This is so binary data can be inserted into btree tables.
1.1605 + */
1.1606 + Tcl_CreateObjCommand(interp, "btree_insert", btree_insert, 0, 0);
1.1607 + return TCL_OK;
1.1608 +}