-C The\sbtree.c\smodule\spasses\sall\stests\sand\sis\sready\sfor\sintegration.\nStill\sneed\sto\sgo\sback\sand\sdo\scoverage\stesting.\s(CVS\s1343)
-D 2004-05-10T18:45:10
+C Work\stoward\sgetting\sthe\snew\sbtree.c\sintegrated\swith\svdbe.c.\s(CVS\s1345)
+D 2004-05-10T23:29:49
F Makefile.in ab7b0d5118e2da97bac66be8684a1034e3500f5a
F Makefile.linux-gcc b86a99c493a5bfb402d1d9178dcdc4bd4b32f906
F README f1de682fbbd94899d50aca13d387d1b3fd3be2dd
F sqlite.pc.in 30552343140c53304c2a658c080fbe810cd09ca2
F src/attach.c fa9a58234406d84eeb900517d0c0adc4b2da051a
F src/auth.c 5c2f0bea4729c98c2be3b69d6b466fc51448fe79
-F src/btree.c 3904c06f69df10a29b49bb3f5c651eb4813980ac
-F src/btree.h 7c3939a2e5f782c1ebac3bf43c02a16febad6df1
+F src/btree.c 38cff183ac4f1d1a2e3079c9eeda7137d103e06e
+F src/btree.h 91343fe6893b8bc35f496bbcecec095a803e5763
F src/btree_rb.c 9d7973e266ee6f9c61ce592f68742ce9cd5b10e5
F src/build.c 8d9965b3ce5dcc1bd4dac60bd0f14524fea269cb
F src/copy.c 4d2038602fd0549d80c59bda27d96f13ea9b5e29
F src/hash.c 440c2f8cb373ee1b4e13a0988489c7cd95d55b6f
F src/hash.h 762d95f1e567664d1eafc1687de755626be962fb
F src/insert.c 2d082257784a8613b1b50cd5bbf42b9466646a0e
-F src/main.c 45f0dc84265d18b0e99500dced4975df8a041481
+F src/main.c 5f8fe4e06fbb79571f4d1a8055bcea2067e2243d
F src/md5.c 8e39fdae6d8776b87558e91dcc94740c9b635a9c
F src/os.c ddcda92f7fd71b4513c57c1ec797917f206d504e
F src/os.h fbb2f6595fc34fa351830d88fe1c6b85118f0383
F src/select.c 9290439282fdc787fdf34d8600dec3a360275c92
F src/shell.c 255b8b9023cb5274f56d87df437e8ce6ef810b91
F src/sqlite.h.in 799c5e726296ec7bc20e6407cdf4df0e0bc00c0c
-F src/sqliteInt.h 3151a1c14fc07f96169e904913d28c7ab173d8ca
+F src/sqliteInt.h 16365a1a4cb28a9edcaada45d40d104112b3544c
F src/table.c af14284fa36c8d41f6829e3f2819dce07d3e2de2
F src/tclsqlite.c a38bf2263a097fcc9603e818c291151de1782c11
F src/test1.c 79956f70dddd1a28f8577bbd61c8cf28e5875eb8
F src/utf.c fc799748d43fe1982d157b871e3e420a19c85d4f
F src/util.c 74ee316594f68c41aed1884d737ab4085d479455
F src/vacuum.c c134702e023db8778e6be59ac0ea7b02315b5476
-F src/vdbe.c 5cd18c8a3ab826f02ef1ce88a5798ec744337b30
+F src/vdbe.c 24a2dbe73ad2f283e70fda6f2ce74ac146239005
F src/vdbe.h 2dc4d1161b64f5684faa6a2d292e318a185ecb2e
-F src/vdbeInt.h 2567223b73d8807d61f8141d9f5e5f7f2975f50a
+F src/vdbeInt.h d5786e1c4f7dadac24e3baeed9847dbfed3016de
F src/vdbeaux.c 943484a2437b6cf40d1ffd3d62e48b5c9a043c5a
F src/where.c 487e55b1f64c8fbf0f46a9a90c2247fc45ae6a9a
F test/all.test 569a92a8ee88f5300c057cc4a8f50fbbc69a3242
-F test/attach.test ba8261d38da6b6a7d4f78ec543c548c4418582ef
+F test/attach.test 76f096f384221f775cc0a856e51d5a35f9ee1541
F test/attach2.test ce61e6185b3cd891cc0e9a4c868fcc65eb92fc55
F test/auth.test 5c4d95cdaf539c0c236e20ce1f71a93e7dde9185
F test/bigfile.test ea904b853ce2d703b16c5ce90e2b54951bc1ae81
F test/tableapi.test e0c4cce61e58343caa84dab33fa6823cb35fe1e1
F test/tclsqlite.test a684fc191b81e6cded8a81263663d5a130fbb013
F test/temptable.test a770ba6308d7f7332fce985086b8e06bed6430c2
-F test/tester.tcl 64babe2528dec64125ddc8c1af763713710b59c3
+F test/tester.tcl 3780967a81e8d3e32caf167c9db3a66210ff69ff
F test/thread1.test 53f050d5be6932d9430df7756edd379366508ff6
F test/threadtest1.c f7f896e62ed46feae1dc411114a48c15a0f82ee2
F test/threadtest2.c d94ca4114fd1504f7e0ae724bcd83d4b40931d86
F www/tclsqlite.tcl b9271d44dcf147a93c98f8ecf28c927307abd6da
F www/vdbe.tcl 9b9095d4495f37697fd1935d10e14c6015e80aa1
F www/whentouse.tcl a8335bce47cc2fddb07f19052cb0cb4d9129a8e4
-P 433ae0d327e5d5b0761e88418ed57fc4cbf4966b
-R 2c4d2a423e133f1d66dbfff76eb51821
+P 84506b23365933383397e02a8ec5a980c57c80fc
+R 00b64215240cbce0ff6f014e73120057
U drh
-Z 4381466dc0ffb9f0d1943a642446ce5b
+Z 014c7bdc3d67480b085cd3793f146069
-84506b23365933383397e02a8ec5a980c57c80fc
\ No newline at end of file
+bc5a2dafa1df74ba6403b4751ac1c33b0fee2884
\ No newline at end of file
** May you share freely, never taking more than you give.
**
*************************************************************************
-** $Id: btree.c,v 1.123 2004/05/10 18:45:10 drh Exp $
+** $Id: btree.c,v 1.124 2004/05/10 23:29:49 drh Exp $
**
** This file implements a external (disk-based) database using BTrees.
** For a detailed discussion of BTrees, refer to
assert( pCur->pPage );
assert( pCur->pPage->isInit );
if( pCur->isValid==0 ){
+ *pRes = -1;
assert( pCur->pPage->nCell==0 );
return SQLITE_OK;
}
if( rc ) return rc;
assert( szNew==cellSize(pPage, newCell) );
assert( szNew<=sizeof(newCell) );
- if( loc==0 ){
+ if( loc==0 && pCur->isValid ){
int szOld;
assert( pCur->idx>=0 && pCur->idx<pPage->nCell );
oldCell = pPage->aCell[pCur->idx];
return SQLITE_OK;
}
+/*
+** Return the flag byte at the beginning of the page that the cursor
+** is currently pointing to.
+*/
+int sqlite3BtreeFlags(BtCursor *pCur){
+ MemPage *pPage = pCur->pPage;
+ return pPage ? pPage->aData[pPage->hdrOffset] : 0;
+}
+
/******************************************************************************
** The complete implementation of the BTree subsystem is above this line.
** All the code the follows is for testing and troubleshooting the BTree
}
#endif
-#ifdef SQLITE_TEST
-/*
-** Return the flag byte at the beginning of the page that the cursor
-** is currently pointing to.
-*/
-int sqlite3BtreeFlags(BtCursor *pCur){
- return pCur->pPage->aData[pCur->pPage->hdrOffset];
-}
-#endif
-
#ifdef SQLITE_TEST
/*
** Fill aResult[] with information about the entry and page that the
** subsystem. See comments in the source code for a detailed description
** of what each interface routine does.
**
-** @(#) $Id: btree.h,v 1.43 2004/05/09 23:23:57 danielk1977 Exp $
+** @(#) $Id: btree.h,v 1.44 2004/05/10 23:29:50 drh Exp $
*/
#ifndef _BTREE_H_
#define _BTREE_H_
int sqlite3BtreeLast(BtCursor*, int *pRes);
int sqlite3BtreeNext(BtCursor*, int *pRes);
int sqlite3BtreeEof(BtCursor*);
+int sqlite3BtreeFlags(BtCursor*);
int sqlite3BtreePrevious(BtCursor*, int *pRes);
int sqlite3BtreeKeySize(BtCursor*, u64 *pSize);
int sqlite3BtreeKey(BtCursor*, u32 offset, u32 amt, void*);
char *sqlite3BtreeIntegrityCheck(Btree*, int *aRoot, int nRoot);
struct Pager *sqlite3BtreePager(Btree*);
+
#ifdef SQLITE_TEST
int sqlite3BtreeCursorInfo(BtCursor*, int*);
void sqlite3BtreeCursorList(Btree*);
-int sqlite3BtreeFlags(BtCursor*);
int sqlite3BtreePageDump(Btree*, int, int recursive);
#endif
** other files are for internal use by SQLite and should not be
** accessed by users of the library.
**
-** $Id: main.c,v 1.168 2004/05/10 10:34:43 danielk1977 Exp $
+** $Id: main.c,v 1.169 2004/05/10 23:29:50 drh Exp $
*/
#include "sqliteInt.h"
#include "os.h"
;
/* The following SQL will read the schema from the master tables.
- ** The first version works with SQLite file formats 2 or greater.
- ** The second version is for format 1 files.
- **
- ** Beginning with file format 2, the rowid for new table entries
- ** (including entries in sqlite_master) is an increasing integer.
- ** So for file format 2 and later, we can play back sqlite_master
- ** and all the CREATE statements will appear in the right order.
- ** But with file format 1, table entries were random and so we
- ** have to make sure the CREATE TABLEs occur before their corresponding
- ** CREATE INDEXs. (We don't have to deal with CREATE VIEW or
- ** CREATE TRIGGER in file format 1 because those constructs did
- ** not exist then.)
*/
static char init_script[] =
-/****** FIX ME
"SELECT type, name, rootpage, sql, 1 FROM sqlite_temp_master "
"UNION ALL "
-*/
"SELECT type, name, rootpage, sql, 0 FROM sqlite_master";
- static char older_init_script[] =
- "SELECT type, name, rootpage, sql, 1 FROM sqlite_temp_master "
- "UNION ALL "
- "SELECT type, name, rootpage, sql, 0 FROM sqlite_master "
- "WHERE type='table' "
- "UNION ALL "
- "SELECT type, name, rootpage, sql, 0 FROM sqlite_master "
- "WHERE type='index'";
-
assert( iDb>=0 && iDb!=1 && iDb<db->nDb );
*/
if( db->aDb[iDb].pBt==0 ) return SQLITE_OK;
rc = sqlite3BtreeCursor(db->aDb[iDb].pBt, MASTER_ROOT, 0, 0, 0, &curMain);
- if( rc ){
+ if( rc!=SQLITE_OK && rc!=SQLITE_EMPTY ){
sqlite3SetString(pzErrMsg, sqlite3_error_string(rc), (char*)0);
return rc;
}
/* Get the database meta information
*/
- {
- int ii;
- for(ii=0; rc==SQLITE_OK && ii<SQLITE_N_BTREE_META; ii++){
- rc = sqlite3BtreeGetMeta(db->aDb[iDb].pBt, ii+1, &meta[ii]);
+ if( rc==SQLITE_OK ){
+ int i;
+ for(i=0; rc==SQLITE_OK && i<SQLITE_N_BTREE_META; i++){
+ rc = sqlite3BtreeGetMeta(db->aDb[iDb].pBt, i+1, &meta[i]);
}
- }
- if( rc ){
- sqlite3SetString(pzErrMsg, sqlite3_error_string(rc), (char*)0);
- sqlite3BtreeCloseCursor(curMain);
- return rc;
+ if( rc ){
+ sqlite3SetString(pzErrMsg, sqlite3_error_string(rc), (char*)0);
+ sqlite3BtreeCloseCursor(curMain);
+ return rc;
+ }
+ }else{
+ memset(meta, 0, sizeof(meta));
}
db->aDb[iDb].schema_cookie = meta[1];
if( iDb==0 ){
if( db->safety_level==0 ) db->safety_level = 2;
/*
- ** file_format==1 Version 2.1.0.
- ** file_format==2 Version 2.2.0. Add support for INTEGER PRIMARY KEY.
- ** file_format==3 Version 2.6.0. Fix empty-string index bug.
- ** file_format==4 Version 2.7.0. Add support for separate numeric and
- ** text datatypes.
+ ** file_format==1 Version 3.0.0.
*/
if( db->file_format==0 ){
/* This happens if the database was initially empty */
- db->file_format = 4;
- }else if( db->file_format>4 ){
+ db->file_format = 1;
+ }else if( db->file_format>1 ){
sqlite3BtreeCloseCursor(curMain);
sqlite3SetString(pzErrMsg, "unsupported file format", (char*)0);
return SQLITE_ERROR;
}
- }else if( db->file_format!=meta[2] || db->file_format<4 ){
- assert( db->file_format>=4 );
+ }else if( db->file_format!=meta[2] ){
if( meta[2]==0 ){
sqlite3SetString(pzErrMsg, "cannot attach empty database: ",
db->aDb[iDb].zName, (char*)0);
*/
assert( db->init.busy );
sqlite3SafetyOff(db);
- if( iDb==0 ){
- rc = sqlite3_exec(db,
- db->file_format>=2 ? init_script : older_init_script,
- sqlite3InitCallback, &initData, 0);
+ if( rc==SQLITE_EMPTY ){
+ /* For an empty database, there is nothing to read */
+ rc = SQLITE_OK;
}else{
- char *zSql = 0;
- sqlite3SetString(&zSql,
- "SELECT type, name, rootpage, sql, ", zDbNum, " FROM \"",
- db->aDb[iDb].zName, "\".sqlite_master", (char*)0);
- rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0);
- sqliteFree(zSql);
+ if( iDb==0 ){
+ rc = sqlite3_exec(db, init_script, sqlite3InitCallback, &initData, 0);
+ }else{
+ char *zSql = 0;
+ sqlite3SetString(&zSql,
+ "SELECT type, name, rootpage, sql, ", zDbNum, " FROM \"",
+ db->aDb[iDb].zName, "\".sqlite_master", (char*)0);
+ rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0);
+ sqliteFree(zSql);
+ }
+ sqlite3SafetyOn(db);
+ sqlite3BtreeCloseCursor(curMain);
}
- sqlite3SafetyOn(db);
- sqlite3BtreeCloseCursor(curMain);
if( sqlite3_malloc_failed ){
sqlite3SetString(pzErrMsg, "out of memory", (char*)0);
rc = SQLITE_NOMEM;
*************************************************************************
** Internal interface definitions for SQLite.
**
-** @(#) $Id: sqliteInt.h,v 1.228 2004/05/10 10:34:52 danielk1977 Exp $
+** @(#) $Id: sqliteInt.h,v 1.229 2004/05/10 23:29:50 drh Exp $
*/
#include "config.h"
#include "sqlite.h"
# define INTPTR_TYPE long long
# endif
#endif
+typedef INT64_TYPE i64; /* 8-byte signed integer */
typedef UINT64_TYPE u64; /* 8-byte unsigned integer */
typedef UINT32_TYPE u32; /* 4-byte unsigned integer */
typedef UINT16_TYPE u16; /* 2-byte unsigned integer */
void *pCommitArg; /* Argument to xCommitCallback() */
int (*xCommitCallback)(void*);/* Invoked at every commit. */
Hash aFunc; /* All functions that can be in SQL exprs */
- int lastRowid; /* ROWID of most recent insert (see above) */
- int priorNewRowid; /* Last randomly generated ROWID */
+ i64 lastRowid; /* ROWID of most recent insert (see above) */
+ i64 priorNewRowid; /* Last randomly generated ROWID */
int magic; /* Magic number for detect library misuse */
int nChange; /* Number of rows changed (see above) */
int lsChange; /* Last statement change count (see above) */
int sqlite3PutVarint(unsigned char *, u64);
int sqlite3GetVarint(const unsigned char *, u64 *);
int sqlite3VarintLen(u64 v);
-
** in this file for details. If in doubt, do not deviate from existing
** commenting and indentation practices when changing or adding code.
**
-** $Id: vdbe.c,v 1.273 2004/05/10 10:35:00 danielk1977 Exp $
+** $Id: vdbe.c,v 1.274 2004/05/10 23:29:50 drh Exp $
*/
#include "sqliteInt.h"
#include "os.h"
** executing this instruction.
*/
case OP_ReadCookie: {
- int aMeta[SQLITE_N_BTREE_META];
+ int iMeta;
assert( pOp->p2<SQLITE_N_BTREE_META );
assert( pOp->p1>=0 && pOp->p1<db->nDb );
assert( db->aDb[pOp->p1].pBt!=0 );
- {
- int ii;
- for(ii=0; rc==SQLITE_OK && ii<SQLITE_N_BTREE_META; ii++){
- rc = sqlite3BtreeGetMeta(db->aDb[pOp->p1].pBt, ii+1, &aMeta[ii]);
- }
- }
+ rc = sqlite3BtreeGetMeta(db->aDb[pOp->p1].pBt, pOp->p2+1, &iMeta);
pTos++;
- pTos->i = aMeta[1+pOp->p2];
+ pTos->i = iMeta;
pTos->flags = MEM_Int;
break;
}
** A transaction must be started before executing this opcode.
*/
case OP_SetCookie: {
- int aMeta[SQLITE_N_BTREE_META];
assert( pOp->p2<SQLITE_N_BTREE_META );
assert( pOp->p1>=0 && pOp->p1<db->nDb );
assert( db->aDb[pOp->p1].pBt!=0 );
assert( pTos>=p->aStack );
- Integerify(pTos)
- {
- int ii;
- for(ii=0; rc==SQLITE_OK && ii<SQLITE_N_BTREE_META; ii++){
- rc = sqlite3BtreeGetMeta(db->aDb[pOp->p1].pBt, ii+1, &aMeta[ii]);
- }
- }
- if( rc==SQLITE_OK ){
- aMeta[1+pOp->p2] = pTos->i;
- {
- int ii;
- for(ii=0; rc==SQLITE_OK && ii<SQLITE_N_BTREE_META; ii++){
- rc = sqlite3BtreeUpdateMeta(db->aDb[pOp->p1].pBt, ii+1, aMeta[ii]);
- }
- }
- }
+ Integerify(pTos);
+ rc = sqlite3BtreeUpdateMeta(db->aDb[pOp->p1].pBt, 1+pOp->p2, (int)pTos->i);
Release(pTos);
pTos--;
break;
** invoked.
*/
case OP_VerifyCookie: {
- int aMeta[SQLITE_N_BTREE_META];
+ int iMeta;
assert( pOp->p1>=0 && pOp->p1<db->nDb );
- {
- int ii;
- for(ii=0; rc==SQLITE_OK && ii<SQLITE_N_BTREE_META; ii++){
- rc = sqlite3BtreeGetMeta(db->aDb[pOp->p1].pBt, ii+1, &aMeta[ii]);
- }
- }
- if( rc==SQLITE_OK && aMeta[1]!=pOp->p2 ){
+ rc = sqlite3BtreeGetMeta(db->aDb[pOp->p1].pBt, 1, &iMeta);
+ if( rc==SQLITE_OK && iMeta!=pOp->p2 ){
sqlite3SetString(&p->zErrMsg, "database schema has changed", (char*)0);
rc = SQLITE_SCHEMA;
}
int wrFlag;
Btree *pX;
int iDb;
+ Cursor *pCur;
assert( pTos>=p->aStack );
Integerify(pTos);
}
assert( i>=0 );
if( expandCursorArraySize(p, i) ) goto no_mem;
- sqlite3VdbeCleanupCursor(&p->aCsr[i]);
- memset(&p->aCsr[i], 0, sizeof(Cursor));
- p->aCsr[i].nullRow = 1;
+ pCur = &p->aCsr[i];
+ sqlite3VdbeCleanupCursor(pCur);
+ memset(pCur, 0, sizeof(Cursor));
+ pCur->nullRow = 1;
if( pX==0 ) break;
do{
- rc = sqlite3BtreeCursor(pX, p2, wrFlag, 0, 0, &p->aCsr[i].pCursor);
+ rc = sqlite3BtreeCursor(pX, p2, wrFlag, 0, 0, &pCur->pCursor);
switch( rc ){
case SQLITE_BUSY: {
if( db->xBusyCallback==0 ){
break;
}
case SQLITE_OK: {
+ int flags = sqlite3BtreeFlags(pCur->pCursor);
+ pCur->intKey = (flags & BTREE_INTKEY)!=0;
+ pCur->zeroData = (flags & BTREE_ZERODATA)!=0;
busy = 0;
break;
}
/* If a transient index is required, create it by calling
** sqlite3BtreeCreateTable() with the BTREE_ZERODATA flag before
** opening it. If a transient table is required, just use the
- ** automatically created table with root-page 2.
+ ** automatically created table with root-page 1.
*/
if( pOp->p2 ){
int pgno;
rc = sqlite3BtreeCreateTable(pCx->pBt, &pgno, BTREE_ZERODATA);
if( rc==SQLITE_OK ){
+ assert( pgno==MASTER_ROOT+1 );
rc = sqlite3BtreeCursor(pCx->pBt, pgno, 1, 0, 0, &pCx->pCursor);
}
}else{
- rc = sqlite3BtreeCursor(pCx->pBt, 2, 1, 0, 0, &pCx->pCursor);
+ rc = sqlite3BtreeCursor(pCx->pBt, MASTER_ROOT, 1, 0, 0, &pCx->pCursor);
}
}
break;
if( pC->pCursor!=0 ){
int res, oc;
pC->nullRow = 0;
- if( pTos->flags & MEM_Int ){
- int iKey = intToKey(pTos->i);
+ if( pC->intKey ){
+ i64 iKey;
+ assert( pTos->flags & MEM_Int );
+ iKey = intToKey(pTos->i);
if( pOp->p2==0 && pOp->opcode==OP_MoveTo ){
pC->movetoTarget = iKey;
pC->deferredMoveto = 1;
pTos--;
break;
}
- sqlite3BtreeMoveto(pC->pCursor, (char*)&iKey, sizeof(int), &res);
+ sqlite3BtreeMoveto(pC->pCursor, 0, (u64)iKey, &res);
pC->lastRecno = pTos->i;
pC->recnoIsValid = res==0;
}else{
/* res might be negative because the table is empty. Check to
** see if this is the case.
*/
- int keysize;
- /* TODO: res = sqlite3BtreeKeySize(pC->pCursor,&keysize)!=0 || * keysize==0; */
+ res = sqlite3BtreeEof(pC->pCursor);
}
if( res && pOp->p2>0 ){
pc = pOp->p2 - 1;
assert( i>=0 && i<p->nCursor );
if( (pC = &p->aCsr[i])->pCursor!=0 ){
int res, rx;
+ assert( pC->intKey==0 );
Stringify(pTos);
rx = sqlite3BtreeMoveto(pC->pCursor, pTos->z, pTos->n, &res);
alreadyExists = rx==SQLITE_OK && res==0;
case OP_IsUnique: {
int i = pOp->p1;
Mem *pNos = &pTos[-1];
+ Cursor *pCx;
BtCursor *pCrsr;
int R;
R = pTos->i;
pTos--;
assert( i>=0 && i<=p->nCursor );
- if( (pCrsr = p->aCsr[i].pCursor)!=0 ){
+ pCx = &p->aCsr[i];
+ pCrsr = pCx->pCursor;
+ if( pCrsr!=0 ){
int res, rc;
int v; /* The record number on the P1 entry that matches K */
char *zKey; /* The value of K */
*/
case OP_NewRecno: {
int i = pOp->p1;
- int v = 0;
+ i64 v = 0;
Cursor *pC;
assert( i>=0 && i<p->nCursor );
if( (pC = &p->aCsr[i])->pCursor==0 ){
- v = 0;
+ /* The zero initialization above is all that is needed */
}else{
/* The next rowid or record number (different terms for the same
** thing) is obtained in a two-step algorithm.
** larger than the previous rowid. This has been shown experimentally
** to double the speed of the COPY operation.
*/
- int res, rx, cnt, x;
+ int res, rx, cnt;
+ i64 x;
cnt = 0;
+ assert( (sqlite3BtreeFlags(pC->pCursor) & BTREE_INTKEY)!=0 );
+ assert( (sqlite3BtreeFlags(pC->pCursor) & BTREE_ZERODATA)==0 );
if( !pC->useRandomRowid ){
if( pC->nextRowidValid ){
v = pC->nextRowid;
if( res ){
v = 1;
}else{
- sqlite3BtreeKey(pC->pCursor, 0, sizeof(v), (void*)&v);
+ sqlite3BtreeKeySize(pC->pCursor, (u64*)&v);
v = keyToInt(v);
- if( v==0x7fffffff ){
+ if( v==0x7fffffffffffffff ){
pC->useRandomRowid = 1;
}else{
v++;
}
}
}
- if( v<0x7fffffff ){
+ if( v<0x7fffffffffffffff ){
pC->nextRowidValid = 1;
pC->nextRowid = v+1;
}else{
}
if( v==0 ) continue;
x = intToKey(v);
- rx = sqlite3BtreeMoveto(pC->pCursor, &x, sizeof(int), &res);
+ rx = sqlite3BtreeMoveto(pC->pCursor, 0, (u64)x, &res);
cnt++;
}while( cnt<1000 && rx==SQLITE_OK && res==0 );
db->priorNewRowid = v;
case OP_Recno: {
int i = pOp->p1;
Cursor *pC;
- int v;
+ i64 v;
assert( i>=0 && i<p->nCursor );
pC = &p->aCsr[i];
break;
}else{
assert( pC->pCursor!=0 );
- sqlite3BtreeKey(pC->pCursor, 0, sizeof(u32), (char*)&v);
+ sqlite3BtreeKeySize(pC->pCursor, (u64*)&v);
v = keyToInt(v);
}
pTos->i = v;
case OP_CreateIndex:
case OP_CreateTable: {
int pgno;
+ int flags;
assert( pOp->p3!=0 && pOp->p3type==P3_POINTER );
assert( pOp->p2>=0 && pOp->p2<db->nDb );
assert( db->aDb[pOp->p2].pBt!=0 );
if( pOp->opcode==OP_CreateTable ){
- rc = sqlite3BtreeCreateTable(db->aDb[pOp->p2].pBt, &pgno, BTREE_INTKEY);
+ flags = BTREE_INTKEY;
}else{
- rc = sqlite3BtreeCreateTable(db->aDb[pOp->p2].pBt, &pgno, BTREE_ZERODATA);
+ flags = BTREE_ZERODATA;
}
+ rc = sqlite3BtreeCreateTable(db->aDb[pOp->p2].pBt, &pgno, flags);
pTos++;
if( rc==SQLITE_OK ){
pTos->i = pgno;
*/
/*
-** When converting from the native format to the key format and back
-** again, in addition to changing the byte order we invert the high-order
-** bit of the most significant byte. This causes negative numbers to
-** sort before positive numbers in the memcmp() function.
+** In the btree layer, a rowid is an unsigned 64-bit integer. In the
+** schema layer, a rowid is a signed 64-bit integer. The following macros
+** convert between the two in such a way as to preserve sort order.
*/
-#define keyToInt(X) (sqlite3VdbeByteSwap(X) ^ 0x80000000)
-#define intToKey(X) (sqlite3VdbeByteSwap((X) ^ 0x80000000))
+#define keyToInt(X) (X ^ 0x8000000000000000)
+#define intToKey(X) (X ^ 0x8000000000000000)
/*
** The makefile scans this source file and creates the following
*/
struct Cursor {
BtCursor *pCursor; /* The cursor structure of the backend */
- int lastRecno; /* Last recno from a Next or NextIdx operation */
- int nextRowid; /* Next rowid returned by OP_NewRowid */
+ i64 lastRecno; /* Last recno from a Next or NextIdx operation */
+ i64 nextRowid; /* Next rowid returned by OP_NewRowid */
Bool recnoIsValid; /* True if lastRecno is valid */
Bool keyAsData; /* The OP_Column command works on key instead of data */
Bool atFirst; /* True if pointing to first entry */
Bool nextRowidValid; /* True if the nextRowid field is valid */
Bool pseudoTable; /* This is a NEW or OLD pseudo-tables of a trigger */
Bool deferredMoveto; /* A call to sqlite3BtreeMoveto() is needed */
- int movetoTarget; /* Argument to the deferred sqlite3BtreeMoveto() */
+ Bool intKey; /* True if the table requires integer keys */
+ Bool zeroData; /* True if table contains keys only - no data */
+ i64 movetoTarget; /* Argument to the deferred sqlite3BtreeMoveto() */
Btree *pBt; /* Separate file holding temporary table */
int nData; /* Number of bytes in pData */
char *pData; /* Data for a NEW or OLD pseudo-table */
- int iKey; /* Key for the NEW or OLD pseudo-table row */
+ i64 iKey; /* Key for the NEW or OLD pseudo-table row */
};
typedef struct Cursor Cursor;
** is an instance of the following structure.
*/
struct Mem {
- int i; /* Integer value */
+ i64 i; /* Integer value */
int n; /* Number of characters in string value, including '\0' */
int flags; /* Some combination of MEM_Null, MEM_Str, MEM_Dyn, etc. */
double r; /* Real value */
# focus of this script is testing the ATTACH and DETACH commands
# and related functionality.
#
-# $Id: attach.test,v 1.13 2004/02/14 01:39:50 drh Exp $
+# $Id: attach.test,v 1.14 2004/05/10 23:29:51 drh Exp $
#
set testdir [file dirname $argv0]
file delete -force test$i.db-journal
}
+set btree_trace 1
do_test attach-1.1 {
execsql {
CREATE TABLE t1(a,b);
# This file implements some common TCL routines used for regression
# testing the SQLite library
#
-# $Id: tester.tcl,v 1.30 2004/05/07 17:57:50 drh Exp $
+# $Id: tester.tcl,v 1.31 2004/05/10 23:29:51 drh Exp $
-if 0 {
# Make sure tclsqlite was compiled correctly. Abort now with an
# error message if not.
#
if {[info exists ::SETUP_SQL]} {
db eval $::SETUP_SQL
}
-}
-proc db {args} {}
# Abort early if this script has been run before.
#
}
}
-# Invoke this procedure on a test that is probabilistic
-# and might fail sometimes.
-#
-proc do_probtest {name cmd expected} {
- global argv nProb nTest skip_test
- if {$skip_test} {
- set skip_test 0
- return
- }
- if {[llength $argv]==0} {
- set go 1
- } else {
- set go 0
- foreach pattern $argv {
- if {[string match $pattern $name]} {
- set go 1
- break
- }
- }
- }
- if {!$go} return
- incr nTest
- puts -nonewline $name...
- flush stdout
- if {[catch {uplevel #0 "$cmd;\n"} result]} {
- puts "\nError: $result"
- incr nErr
- } elseif {[string compare $result $expected]} {
- puts "\nExpected: \[$expected\]\n Got: \[$result\]"
- puts "NOTE: The results of the previous test depend on system load"
- puts "and processor speed. The test may sometimes fail even if the"
- puts "library is working correctly."
- incr nProb
- } else {
- puts " Ok"
- }
-}
-
# The procedure uses the special "sqlite_malloc_stat" command
# (which is only available if SQLite is compiled with -DMEMORY_DEBUG=1)
# to see how many malloc()s have not been free()ed. The number
projects / thirdparty / sqlite.git / commitdiff
