diff options
Diffstat (limited to 'kopete/plugins/statistics/sqlite/vdbeaux.c')
| -rw-r--r-- | kopete/plugins/statistics/sqlite/vdbeaux.c | 1806 |
1 files changed, 1806 insertions, 0 deletions
diff --git a/kopete/plugins/statistics/sqlite/vdbeaux.c b/kopete/plugins/statistics/sqlite/vdbeaux.c new file mode 100644 index 00000000..fa9751da --- /dev/null +++ b/kopete/plugins/statistics/sqlite/vdbeaux.c @@ -0,0 +1,1806 @@ +/* +** 2003 September 6 +** +** The author disclaims copyright to this source code. In place of +** a legal notice, here is a blessing: +** +** May you do good and not evil. +** May you find forgiveness for yourself and forgive others. +** May you share freely, never taking more than you give. +** +************************************************************************* +** This file contains code used for creating, destroying, and populating +** a VDBE (or an "sqlite3_stmt" as it is known to the outside world.) Prior +** to version 2.8.7, all this code was combined into the vdbe.c source file. +** But that file was getting too big so this subroutines were split out. +*/ +#include "sqliteInt.h" +#include "os.h" +#include <ctype.h> +#include "vdbeInt.h" + + +/* +** When debugging the code generator in a symbolic debugger, one can +** set the sqlite3_vdbe_addop_trace to 1 and all opcodes will be printed +** as they are added to the instruction stream. +*/ +#ifndef NDEBUG +int sqlite3_vdbe_addop_trace = 0; +#endif + + +/* +** Create a new virtual database engine. +*/ +Vdbe *sqlite3VdbeCreate(sqlite3 *db){ + Vdbe *p; + p = sqliteMalloc( sizeof(Vdbe) ); + if( p==0 ) return 0; + p->db = db; + if( db->pVdbe ){ + db->pVdbe->pPrev = p; + } + p->pNext = db->pVdbe; + p->pPrev = 0; + db->pVdbe = p; + p->magic = VDBE_MAGIC_INIT; + return p; +} + +/* +** Turn tracing on or off +*/ +void sqlite3VdbeTrace(Vdbe *p, FILE *trace){ + p->trace = trace; +} + +/* +** Resize the Vdbe.aOp array so that it contains at least N +** elements. +*/ +static void resizeOpArray(Vdbe *p, int N){ + if( p->nOpAlloc<N ){ + int oldSize = p->nOpAlloc; + p->nOpAlloc = N+100; + p->aOp = sqliteRealloc(p->aOp, p->nOpAlloc*sizeof(Op)); + if( p->aOp ){ + memset(&p->aOp[oldSize], 0, (p->nOpAlloc-oldSize)*sizeof(Op)); + } + } +} + +/* +** Add a new instruction to the list of instructions current in the +** VDBE. Return the address of the new instruction. +** +** Parameters: +** +** p Pointer to the VDBE +** +** op The opcode for this instruction +** +** p1, p2 First two of the three possible operands. +** +** Use the sqlite3VdbeResolveLabel() function to fix an address and +** the sqlite3VdbeChangeP3() function to change the value of the P3 +** operand. +*/ +int sqlite3VdbeAddOp(Vdbe *p, int op, int p1, int p2){ + int i; + VdbeOp *pOp; + + i = p->nOp; + p->nOp++; + assert( p->magic==VDBE_MAGIC_INIT ); + resizeOpArray(p, i+1); + if( p->aOp==0 ){ + return 0; + } + pOp = &p->aOp[i]; + pOp->opcode = op; + pOp->p1 = p1; + pOp->p2 = p2; + pOp->p3 = 0; + pOp->p3type = P3_NOTUSED; +#ifndef NDEBUG + if( sqlite3_vdbe_addop_trace ) sqlite3VdbePrintOp(0, i, &p->aOp[i]); +#endif + return i; +} + +/* +** Add an opcode that includes the p3 value. +*/ +int sqlite3VdbeOp3(Vdbe *p, int op, int p1, int p2, const char *zP3,int p3type){ + int addr = sqlite3VdbeAddOp(p, op, p1, p2); + sqlite3VdbeChangeP3(p, addr, zP3, p3type); + return addr; +} + +/* +** Create a new symbolic label for an instruction that has yet to be +** coded. The symbolic label is really just a negative number. The +** label can be used as the P2 value of an operation. Later, when +** the label is resolved to a specific address, the VDBE will scan +** through its operation list and change all values of P2 which match +** the label into the resolved address. +** +** The VDBE knows that a P2 value is a label because labels are +** always negative and P2 values are suppose to be non-negative. +** Hence, a negative P2 value is a label that has yet to be resolved. +** +** Zero is returned if a malloc() fails. +*/ +int sqlite3VdbeMakeLabel(Vdbe *p){ + int i; + i = p->nLabel++; + assert( p->magic==VDBE_MAGIC_INIT ); + if( i>=p->nLabelAlloc ){ + p->nLabelAlloc = p->nLabelAlloc*2 + 10; + p->aLabel = sqliteRealloc( p->aLabel, p->nLabelAlloc*sizeof(p->aLabel[0])); + } + if( p->aLabel ){ + p->aLabel[i] = -1; + } + return -1-i; +} + +/* +** Resolve label "x" to be the address of the next instruction to +** be inserted. The parameter "x" must have been obtained from +** a prior call to sqlite3VdbeMakeLabel(). +*/ +void sqlite3VdbeResolveLabel(Vdbe *p, int x){ + int j = -1-x; + assert( p->magic==VDBE_MAGIC_INIT ); + assert( j>=0 && j<p->nLabel ); + if( p->aLabel ){ + p->aLabel[j] = p->nOp; + } +} + +/* +** Loop through the program looking for P2 values that are negative. +** Each such value is a label. Resolve the label by setting the P2 +** value to its correct non-zero value. +** +** This routine is called once after all opcodes have been inserted. +*/ +static void resolveP2Values(Vdbe *p){ + int i; + Op *pOp; + int *aLabel = p->aLabel; + if( aLabel==0 ) return; + for(pOp=p->aOp, i=p->nOp-1; i>=0; i--, pOp++){ + if( pOp->p2>=0 ) continue; + assert( -1-pOp->p2<p->nLabel ); + pOp->p2 = aLabel[-1-pOp->p2]; + } + sqliteFree(p->aLabel); + p->aLabel = 0; +} + +/* +** Return the address of the next instruction to be inserted. +*/ +int sqlite3VdbeCurrentAddr(Vdbe *p){ + assert( p->magic==VDBE_MAGIC_INIT ); + return p->nOp; +} + +/* +** Add a whole list of operations to the operation stack. Return the +** address of the first operation added. +*/ +int sqlite3VdbeAddOpList(Vdbe *p, int nOp, VdbeOpList const *aOp){ + int addr; + assert( p->magic==VDBE_MAGIC_INIT ); + resizeOpArray(p, p->nOp + nOp); + if( p->aOp==0 ){ + return 0; + } + addr = p->nOp; + if( nOp>0 ){ + int i; + VdbeOpList const *pIn = aOp; + for(i=0; i<nOp; i++, pIn++){ + int p2 = pIn->p2; + VdbeOp *pOut = &p->aOp[i+addr]; + pOut->opcode = pIn->opcode; + pOut->p1 = pIn->p1; + pOut->p2 = p2<0 ? addr + ADDR(p2) : p2; + pOut->p3 = pIn->p3; + pOut->p3type = pIn->p3 ? P3_STATIC : P3_NOTUSED; +#ifndef NDEBUG + if( sqlite3_vdbe_addop_trace ){ + sqlite3VdbePrintOp(0, i+addr, &p->aOp[i+addr]); + } +#endif + } + p->nOp += nOp; + } + return addr; +} + +/* +** Change the value of the P1 operand for a specific instruction. +** This routine is useful when a large program is loaded from a +** static array using sqlite3VdbeAddOpList but we want to make a +** few minor changes to the program. +*/ +void sqlite3VdbeChangeP1(Vdbe *p, int addr, int val){ + assert( p->magic==VDBE_MAGIC_INIT ); + if( p && addr>=0 && p->nOp>addr && p->aOp ){ + p->aOp[addr].p1 = val; + } +} + +/* +** Change the value of the P2 operand for a specific instruction. +** This routine is useful for setting a jump destination. +*/ +void sqlite3VdbeChangeP2(Vdbe *p, int addr, int val){ + assert( val>=0 ); + assert( p->magic==VDBE_MAGIC_INIT ); + if( p && addr>=0 && p->nOp>addr && p->aOp ){ + p->aOp[addr].p2 = val; + } +} + +/* +** Change the value of the P3 operand for a specific instruction. +** This routine is useful when a large program is loaded from a +** static array using sqlite3VdbeAddOpList but we want to make a +** few minor changes to the program. +** +** If n>=0 then the P3 operand is dynamic, meaning that a copy of +** the string is made into memory obtained from sqliteMalloc(). +** A value of n==0 means copy bytes of zP3 up to and including the +** first null byte. If n>0 then copy n+1 bytes of zP3. +** +** If n==P3_STATIC it means that zP3 is a pointer to a constant static +** string and we can just copy the pointer. n==P3_POINTER means zP3 is +** a pointer to some object other than a string. n==P3_COLLSEQ and +** n==P3_KEYINFO mean that zP3 is a pointer to a CollSeq or KeyInfo +** structure. A copy is made of KeyInfo structures into memory obtained +** from sqliteMalloc. +** +** If addr<0 then change P3 on the most recently inserted instruction. +*/ +void sqlite3VdbeChangeP3(Vdbe *p, int addr, const char *zP3, int n){ + Op *pOp; + assert( p->magic==VDBE_MAGIC_INIT ); + if( p==0 || p->aOp==0 ) return; + if( addr<0 || addr>=p->nOp ){ + addr = p->nOp - 1; + if( addr<0 ) return; + } + pOp = &p->aOp[addr]; + if( pOp->p3 && pOp->p3type==P3_DYNAMIC ){ + sqliteFree(pOp->p3); + pOp->p3 = 0; + } + if( zP3==0 ){ + pOp->p3 = 0; + pOp->p3type = P3_NOTUSED; + }else if( n==P3_KEYINFO ){ + KeyInfo *pKeyInfo; + int nField, nByte; + nField = ((KeyInfo*)zP3)->nField; + nByte = sizeof(*pKeyInfo) + (nField-1)*sizeof(pKeyInfo->aColl[0]); + pKeyInfo = sqliteMallocRaw( nByte ); + pOp->p3 = (char*)pKeyInfo; + if( pKeyInfo ){ + memcpy(pKeyInfo, zP3, nByte); + pOp->p3type = P3_KEYINFO; + }else{ + pOp->p3type = P3_NOTUSED; + } + }else if( n==P3_KEYINFO_HANDOFF ){ + pOp->p3 = (char*)zP3; + pOp->p3type = P3_KEYINFO; + }else if( n<0 ){ + pOp->p3 = (char*)zP3; + pOp->p3type = n; + }else{ + if( n==0 ) n = strlen(zP3); + pOp->p3 = sqliteStrNDup(zP3, n); + pOp->p3type = P3_DYNAMIC; + } +} + +#ifndef NDEBUG +/* +** Replace the P3 field of the most recently coded instruction with +** comment text. +*/ +void sqlite3VdbeComment(Vdbe *p, const char *zFormat, ...){ + va_list ap; + assert( p->nOp>0 ); + assert( p->aOp==0 || p->aOp[p->nOp-1].p3==0 ); + va_start(ap, zFormat); + sqlite3VdbeChangeP3(p, -1, sqlite3VMPrintf(zFormat, ap), P3_DYNAMIC); + va_end(ap); +} +#endif + +/* +** If the P3 operand to the specified instruction appears +** to be a quoted string token, then this procedure removes +** the quotes. +** +** The quoting operator can be either a grave ascent (ASCII 0x27) +** or a double quote character (ASCII 0x22). Two quotes in a row +** resolve to be a single actual quote character within the string. +*/ +void sqlite3VdbeDequoteP3(Vdbe *p, int addr){ + Op *pOp; + assert( p->magic==VDBE_MAGIC_INIT ); + if( p->aOp==0 ) return; + if( addr<0 || addr>=p->nOp ){ + addr = p->nOp - 1; + if( addr<0 ) return; + } + pOp = &p->aOp[addr]; + if( pOp->p3==0 || pOp->p3[0]==0 ) return; + if( pOp->p3type==P3_STATIC ){ + pOp->p3 = sqliteStrDup(pOp->p3); + pOp->p3type = P3_DYNAMIC; + } + assert( pOp->p3type==P3_DYNAMIC ); + sqlite3Dequote(pOp->p3); +} + +/* +** Search the current program starting at instruction addr for the given +** opcode and P2 value. Return the address plus 1 if found and 0 if not +** found. +*/ +int sqlite3VdbeFindOp(Vdbe *p, int addr, int op, int p2){ + int i; + assert( p->magic==VDBE_MAGIC_INIT ); + for(i=addr; i<p->nOp; i++){ + if( p->aOp[i].opcode==op && p->aOp[i].p2==p2 ) return i+1; + } + return 0; +} + +/* +** Return the opcode for a given address. +*/ +VdbeOp *sqlite3VdbeGetOp(Vdbe *p, int addr){ + assert( p->magic==VDBE_MAGIC_INIT ); + assert( addr>=0 && addr<p->nOp ); + return &p->aOp[addr]; +} + +/* +** Compute a string that describes the P3 parameter for an opcode. +** Use zTemp for any required temporary buffer space. +*/ +static char *displayP3(Op *pOp, char *zTemp, int nTemp){ + char *zP3; + assert( nTemp>=20 ); + switch( pOp->p3type ){ + case P3_POINTER: { + sprintf(zTemp, "ptr(%#x)", (int)pOp->p3); + zP3 = zTemp; + break; + } + case P3_KEYINFO: { + int i, j; + KeyInfo *pKeyInfo = (KeyInfo*)pOp->p3; + sprintf(zTemp, "keyinfo(%d", pKeyInfo->nField); + i = strlen(zTemp); + for(j=0; j<pKeyInfo->nField; j++){ + CollSeq *pColl = pKeyInfo->aColl[j]; + if( pColl ){ + int n = strlen(pColl->zName); + if( i+n>nTemp-6 ){ + strcpy(&zTemp[i],",..."); + break; + } + zTemp[i++] = ','; + if( pKeyInfo->aSortOrder && pKeyInfo->aSortOrder[j] ){ + zTemp[i++] = '-'; + } + strcpy(&zTemp[i], pColl->zName); + i += n; + }else if( i+4<nTemp-6 ){ + strcpy(&zTemp[i],",nil"); + i += 4; + } + } + zTemp[i++] = ')'; + zTemp[i] = 0; + assert( i<nTemp ); + zP3 = zTemp; + break; + } + case P3_COLLSEQ: { + CollSeq *pColl = (CollSeq*)pOp->p3; + sprintf(zTemp, "collseq(%.20s)", pColl->zName); + zP3 = zTemp; + break; + } + case P3_FUNCDEF: { + FuncDef *pDef = (FuncDef*)pOp->p3; + char zNum[30]; + sprintf(zTemp, "%.*s", nTemp, pDef->zName); + sprintf(zNum,"(%d)", pDef->nArg); + if( strlen(zTemp)+strlen(zNum)+1<=nTemp ){ + strcat(zTemp, zNum); + } + zP3 = zTemp; + break; + } + default: { + zP3 = pOp->p3; + if( zP3==0 || pOp->opcode==OP_Noop ){ + zP3 = ""; + } + } + } + return zP3; +} + + +#if !defined(NDEBUG) || defined(VDBE_PROFILE) || defined(SQLITE_DEBUG) +/* +** Print a single opcode. This routine is used for debugging only. +*/ +void sqlite3VdbePrintOp(FILE *pOut, int pc, Op *pOp){ + char *zP3; + char zPtr[50]; + static const char *zFormat1 = "%4d %-13s %4d %4d %s\n"; + if( pOut==0 ) pOut = stdout; + zP3 = displayP3(pOp, zPtr, sizeof(zPtr)); + fprintf(pOut, zFormat1, + pc, sqlite3OpcodeNames[pOp->opcode], pOp->p1, pOp->p2, zP3); + fflush(pOut); +} +#endif + +/* +** Release an array of N Mem elements +*/ +static void releaseMemArray(Mem *p, int N){ + if( p ){ + while( N-->0 ){ + sqlite3VdbeMemRelease(p++); + } + } +} + +/* +** Give a listing of the program in the virtual machine. +** +** The interface is the same as sqlite3VdbeExec(). But instead of +** running the code, it invokes the callback once for each instruction. +** This feature is used to implement "EXPLAIN". +*/ +int sqlite3VdbeList( + Vdbe *p /* The VDBE */ +){ + sqlite3 *db = p->db; + int i; + int rc = SQLITE_OK; + + assert( p->explain ); + + /* Even though this opcode does not put dynamic strings onto the + ** the stack, they may become dynamic if the user calls + ** sqlite3_column_text16(), causing a translation to UTF-16 encoding. + */ + if( p->pTos==&p->aStack[4] ){ + releaseMemArray(p->aStack, 5); + } + p->resOnStack = 0; + + i = p->pc++; + if( i>=p->nOp ){ + p->rc = SQLITE_OK; + rc = SQLITE_DONE; + }else if( db->flags & SQLITE_Interrupt ){ + db->flags &= ~SQLITE_Interrupt; + if( db->magic!=SQLITE_MAGIC_BUSY ){ + p->rc = SQLITE_MISUSE; + }else{ + p->rc = SQLITE_INTERRUPT; + } + rc = SQLITE_ERROR; + sqlite3SetString(&p->zErrMsg, sqlite3ErrStr(p->rc), (char*)0); + }else{ + Op *pOp = &p->aOp[i]; + Mem *pMem = p->aStack; + pMem->flags = MEM_Int; + pMem->type = SQLITE_INTEGER; + pMem->i = i; /* Program counter */ + pMem++; + + pMem->flags = MEM_Static|MEM_Str|MEM_Term; + pMem->z = sqlite3OpcodeNames[pOp->opcode]; /* Opcode */ + pMem->n = strlen(pMem->z); + pMem->type = SQLITE_TEXT; + pMem->enc = SQLITE_UTF8; + pMem++; + + pMem->flags = MEM_Int; + pMem->i = pOp->p1; /* P1 */ + pMem->type = SQLITE_INTEGER; + pMem++; + + pMem->flags = MEM_Int; + pMem->i = pOp->p2; /* P2 */ + pMem->type = SQLITE_INTEGER; + pMem++; + + pMem->flags = MEM_Short|MEM_Str|MEM_Term; /* P3 */ + pMem->z = displayP3(pOp, pMem->zShort, sizeof(pMem->zShort)); + pMem->type = SQLITE_TEXT; + pMem->enc = SQLITE_UTF8; + + p->nResColumn = 5; + p->pTos = pMem; + p->rc = SQLITE_OK; + p->resOnStack = 1; + rc = SQLITE_ROW; + } + return rc; +} + +/* +** Print the SQL that was used to generate a VDBE program. +*/ +void sqlite3VdbePrintSql(Vdbe *p){ +#ifdef SQLITE_DEBUG + int nOp = p->nOp; + VdbeOp *pOp; + if( nOp<1 ) return; + pOp = &p->aOp[nOp-1]; + if( pOp->opcode==OP_Noop && pOp->p3!=0 ){ + const char *z = pOp->p3; + while( isspace(*(u8*)z) ) z++; + printf("SQL: [%s]\n", z); + } +#endif +} + +/* +** Prepare a virtual machine for execution. This involves things such +** as allocating stack space and initializing the program counter. +** After the VDBE has be prepped, it can be executed by one or more +** calls to sqlite3VdbeExec(). +** +** This is the only way to move a VDBE from VDBE_MAGIC_INIT to +** VDBE_MAGIC_RUN. +*/ +void sqlite3VdbeMakeReady( + Vdbe *p, /* The VDBE */ + int nVar, /* Number of '?' see in the SQL statement */ + int nMem, /* Number of memory cells to allocate */ + int nCursor, /* Number of cursors to allocate */ + int isExplain /* True if the EXPLAIN keywords is present */ +){ + int n; + + assert( p!=0 ); + assert( p->magic==VDBE_MAGIC_INIT ); + + /* There should be at least one opcode. + */ + assert( p->nOp>0 ); + + /* No instruction ever pushes more than a single element onto the + ** stack. And the stack never grows on successive executions of the + ** same loop. So the total number of instructions is an upper bound + ** on the maximum stack depth required. + ** + ** Allocation all the stack space we will ever need. + */ + if( p->aStack==0 ){ + resolveP2Values(p); + assert( nVar>=0 ); + n = isExplain ? 10 : p->nOp; + p->aStack = sqliteMalloc( + n*sizeof(p->aStack[0]) /* aStack */ + + n*sizeof(Mem*) /* apArg */ + + nVar*sizeof(Mem) /* aVar */ + + nVar*sizeof(char*) /* azVar */ + + nMem*sizeof(Mem) /* aMem */ + + nCursor*sizeof(Cursor*) /* apCsr */ + ); + if( !sqlite3_malloc_failed ){ + p->aMem = &p->aStack[n]; + p->nMem = nMem; + p->aVar = &p->aMem[nMem]; + p->nVar = nVar; + p->okVar = 0; + p->apArg = (Mem**)&p->aVar[nVar]; + p->azVar = (char**)&p->apArg[n]; + p->apCsr = (Cursor**)&p->azVar[nVar]; + p->nCursor = nCursor; + for(n=0; n<nVar; n++){ + p->aVar[n].flags = MEM_Null; + } + for(n=0; n<nMem; n++){ + p->aMem[n].flags = MEM_Null; + } + } + } + +#ifdef SQLITE_DEBUG + if( (p->db->flags & SQLITE_VdbeListing)!=0 + || sqlite3OsFileExists("vdbe_explain") + ){ + int i; + printf("VDBE Program Listing:\n"); + sqlite3VdbePrintSql(p); + for(i=0; i<p->nOp; i++){ + sqlite3VdbePrintOp(stdout, i, &p->aOp[i]); + } + } + if( sqlite3OsFileExists("vdbe_trace") ){ + p->trace = stdout; + } +#endif + p->pTos = &p->aStack[-1]; + p->pc = -1; + p->rc = SQLITE_OK; + p->uniqueCnt = 0; + p->returnDepth = 0; + p->errorAction = OE_Abort; + p->popStack = 0; + p->explain |= isExplain; + p->magic = VDBE_MAGIC_RUN; + p->nChange = 0; +#ifdef VDBE_PROFILE + { + int i; + for(i=0; i<p->nOp; i++){ + p->aOp[i].cnt = 0; + p->aOp[i].cycles = 0; + } + } +#endif +} + + +/* +** Remove any elements that remain on the sorter for the VDBE given. +*/ +void sqlite3VdbeSorterReset(Vdbe *p){ + while( p->pSort ){ + Sorter *pSorter = p->pSort; + p->pSort = pSorter->pNext; + sqliteFree(pSorter->zKey); + sqlite3VdbeMemRelease(&pSorter->data); + sqliteFree(pSorter); + } +} + +/* +** Free all resources allociated with AggElem pElem, an element of +** aggregate pAgg. +*/ +void freeAggElem(AggElem *pElem, Agg *pAgg){ + int i; + for(i=0; i<pAgg->nMem; i++){ + Mem *pMem = &pElem->aMem[i]; + if( pAgg->apFunc && pAgg->apFunc[i] && (pMem->flags & MEM_AggCtx)!=0 ){ + sqlite3_context ctx; + ctx.pFunc = pAgg->apFunc[i]; + ctx.s.flags = MEM_Null; + ctx.pAgg = pMem->z; + ctx.cnt = pMem->i; + ctx.isStep = 0; + ctx.isError = 0; + (*pAgg->apFunc[i]->xFinalize)(&ctx); + pMem->z = ctx.pAgg; + if( pMem->z!=0 && pMem->z!=pMem->zShort ){ + sqliteFree(pMem->z); + } + sqlite3VdbeMemRelease(&ctx.s); + }else{ + sqlite3VdbeMemRelease(pMem); + } + } + sqliteFree(pElem); +} + +/* +** Reset an Agg structure. Delete all its contents. +** +** For installable aggregate functions, if the step function has been +** called, make sure the finalizer function has also been called. The +** finalizer might need to free memory that was allocated as part of its +** private context. If the finalizer has not been called yet, call it +** now. +** +** If db is NULL, then this is being called from sqliteVdbeReset(). In +** this case clean up all references to the temp-table used for +** aggregates (if it was ever opened). +** +** If db is not NULL, then this is being called from with an OP_AggReset +** opcode. Open the temp-table, if it has not already been opened and +** delete the contents of the table used for aggregate information, ready +** for the next round of aggregate processing. +*/ +int sqlite3VdbeAggReset(sqlite3 *db, Agg *pAgg, KeyInfo *pKeyInfo){ + int rc = 0; + BtCursor *pCsr = pAgg->pCsr; + + assert( (pCsr && pAgg->nTab>0) || (!pCsr && pAgg->nTab==0) + || sqlite3_malloc_failed ); + + /* If pCsr is not NULL, then the table used for aggregate information + ** is open. Loop through it and free the AggElem* structure pointed at + ** by each entry. If the finalizer has not been called for an AggElem, + ** do that too. Finally, clear the btree table itself. + */ + if( pCsr ){ + int res; + assert( pAgg->pBtree ); + assert( pAgg->nTab>0 ); + + rc=sqlite3BtreeFirst(pCsr, &res); + while( res==0 && rc==SQLITE_OK ){ + AggElem *pElem; + rc = sqlite3BtreeData(pCsr, 0, sizeof(AggElem*), (char *)&pElem); + if( res!=SQLITE_OK ){ + return rc; + } + assert( pAgg->apFunc!=0 ); + freeAggElem(pElem, pAgg); + rc=sqlite3BtreeNext(pCsr, &res); + } + if( rc!=SQLITE_OK ){ + return rc; + } + + sqlite3BtreeCloseCursor(pCsr); + sqlite3BtreeClearTable(pAgg->pBtree, pAgg->nTab); + }else{ + /* The cursor may not be open because the aggregator was never used, + ** or it could be that it was used but there was no GROUP BY clause. + */ + if( pAgg->pCurrent ){ + freeAggElem(pAgg->pCurrent, pAgg); + } + } + + /* If db is not NULL and we have not yet and we have not yet opened + ** the temporary btree then do so and create the table to store aggregate + ** information. + ** + ** If db is NULL, then close the temporary btree if it is open. + */ + if( db ){ + if( !pAgg->pBtree ){ + assert( pAgg->nTab==0 ); + rc = sqlite3BtreeFactory(db, ":memory:", 0, TEMP_PAGES, &pAgg->pBtree); + if( rc!=SQLITE_OK ) return rc; + sqlite3BtreeBeginTrans(pAgg->pBtree, 1); + rc = sqlite3BtreeCreateTable(pAgg->pBtree, &pAgg->nTab, 0); + if( rc!=SQLITE_OK ) return rc; + } + assert( pAgg->nTab!=0 ); + + rc = sqlite3BtreeCursor(pAgg->pBtree, pAgg->nTab, 1, + sqlite3VdbeRecordCompare, pKeyInfo, &pAgg->pCsr); + if( rc!=SQLITE_OK ) return rc; + }else{ + if( pAgg->pBtree ){ + sqlite3BtreeClose(pAgg->pBtree); + pAgg->pBtree = 0; + pAgg->nTab = 0; + } + pAgg->pCsr = 0; + } + + if( pAgg->apFunc ){ + sqliteFree(pAgg->apFunc); + pAgg->apFunc = 0; + } + pAgg->pCurrent = 0; + pAgg->nMem = 0; + pAgg->searching = 0; + return SQLITE_OK; +} + + +/* +** Delete a keylist +*/ +void sqlite3VdbeKeylistFree(Keylist *p){ + while( p ){ + Keylist *pNext = p->pNext; + sqliteFree(p); + p = pNext; + } +} + +/* +** Close a cursor and release all the resources that cursor happens +** to hold. +*/ +void sqlite3VdbeFreeCursor(Cursor *pCx){ + if( pCx==0 ){ + return; + } + if( pCx->pCursor ){ + sqlite3BtreeCloseCursor(pCx->pCursor); + } + if( pCx->pBt ){ + sqlite3BtreeClose(pCx->pBt); + } + sqliteFree(pCx->pData); + sqliteFree(pCx->aType); + sqliteFree(pCx); +} + +/* +** Close all cursors +*/ +static void closeAllCursors(Vdbe *p){ + int i; + if( p->apCsr==0 ) return; + for(i=0; i<p->nCursor; i++){ + sqlite3VdbeFreeCursor(p->apCsr[i]); + p->apCsr[i] = 0; + } +} + +/* +** Clean up the VM after execution. +** +** This routine will automatically close any cursors, lists, and/or +** sorters that were left open. It also deletes the values of +** variables in the aVar[] array. +*/ +static void Cleanup(Vdbe *p){ + int i; + if( p->aStack ){ + releaseMemArray(p->aStack, 1 + (p->pTos - p->aStack)); + p->pTos = &p->aStack[-1]; + } + closeAllCursors(p); + releaseMemArray(p->aMem, p->nMem); + if( p->pList ){ + sqlite3VdbeKeylistFree(p->pList); + p->pList = 0; + } + if( p->contextStack ){ + for(i=0; i<p->contextStackTop; i++){ + sqlite3VdbeKeylistFree(p->contextStack[i].pList); + } + sqliteFree(p->contextStack); + } + sqlite3VdbeSorterReset(p); + sqlite3VdbeAggReset(0, &p->agg, 0); + p->contextStack = 0; + p->contextStackDepth = 0; + p->contextStackTop = 0; + sqliteFree(p->zErrMsg); + p->zErrMsg = 0; +} + +/* +** Set the number of result columns that will be returned by this SQL +** statement. This is now set at compile time, rather than during +** execution of the vdbe program so that sqlite3_column_count() can +** be called on an SQL statement before sqlite3_step(). +*/ +void sqlite3VdbeSetNumCols(Vdbe *p, int nResColumn){ + Mem *pColName; + int n; + assert( 0==p->nResColumn ); + p->nResColumn = nResColumn; + n = nResColumn*2; + p->aColName = pColName = (Mem*)sqliteMalloc( sizeof(Mem)*n ); + if( p->aColName==0 ) return; + while( n-- > 0 ){ + (pColName++)->flags = MEM_Null; + } +} + +/* +** Set the name of the idx'th column to be returned by the SQL statement. +** zName must be a pointer to a nul terminated string. +** +** This call must be made after a call to sqlite3VdbeSetNumCols(). +** +** If N==P3_STATIC it means that zName is a pointer to a constant static +** string and we can just copy the pointer. If it is P3_DYNAMIC, then +** the string is freed using sqliteFree() when the vdbe is finished with +** it. Otherwise, N bytes of zName are copied. +*/ +int sqlite3VdbeSetColName(Vdbe *p, int idx, const char *zName, int N){ + int rc; + Mem *pColName; + assert( idx<(2*p->nResColumn) ); + if( sqlite3_malloc_failed ) return SQLITE_NOMEM; + assert( p->aColName!=0 ); + pColName = &(p->aColName[idx]); + if( N==P3_DYNAMIC || N==P3_STATIC ){ + rc = sqlite3VdbeMemSetStr(pColName, zName, -1, SQLITE_UTF8, SQLITE_STATIC); + }else{ + rc = sqlite3VdbeMemSetStr(pColName, zName, N, SQLITE_UTF8,SQLITE_TRANSIENT); + } + if( rc==SQLITE_OK && N==P3_DYNAMIC ){ + pColName->flags = (pColName->flags&(~MEM_Static))|MEM_Dyn; + pColName->xDel = 0; + } + return rc; +} + +/* +** A read or write transaction may or may not be active on database handle +** db. If a transaction is active, commit it. If there is a +** write-transaction spanning more than one database file, this routine +** takes care of the master journal trickery. +*/ +static int vdbeCommit(sqlite3 *db){ + int i; + int nTrans = 0; /* Number of databases with an active write-transaction */ + int rc = SQLITE_OK; + int needXcommit = 0; + + for(i=0; i<db->nDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( pBt && sqlite3BtreeIsInTrans(pBt) ){ + needXcommit = 1; + if( i!=1 ) nTrans++; + } + } + + /* If there are any write-transactions at all, invoke the commit hook */ + if( needXcommit && db->xCommitCallback ){ + int rc; + sqlite3SafetyOff(db); + rc = db->xCommitCallback(db->pCommitArg); + sqlite3SafetyOn(db); + if( rc ){ + return SQLITE_CONSTRAINT; + } + } + + /* The simple case - no more than one database file (not counting the + ** TEMP database) has a transaction active. There is no need for the + ** master-journal. + ** + ** If the return value of sqlite3BtreeGetFilename() is a zero length + ** string, it means the main database is :memory:. In that case we do + ** not support atomic multi-file commits, so use the simple case then + ** too. + */ + if( 0==strlen(sqlite3BtreeGetFilename(db->aDb[0].pBt)) || nTrans<=1 ){ + for(i=0; rc==SQLITE_OK && i<db->nDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( pBt ){ + rc = sqlite3BtreeSync(pBt, 0); + } + } + + /* Do the commit only if all databases successfully synced */ + if( rc==SQLITE_OK ){ + for(i=0; i<db->nDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( pBt ){ + sqlite3BtreeCommit(pBt); + } + } + } + } + + /* The complex case - There is a multi-file write-transaction active. + ** This requires a master journal file to ensure the transaction is + ** committed atomicly. + */ + else{ + char *zMaster = 0; /* File-name for the master journal */ + char const *zMainFile = sqlite3BtreeGetFilename(db->aDb[0].pBt); + OsFile master; + + /* Select a master journal file name */ + do { + u32 random; + sqliteFree(zMaster); + sqlite3Randomness(sizeof(random), &random); + zMaster = sqlite3MPrintf("%s-mj%08X", zMainFile, random&0x7fffffff); + if( !zMaster ){ + return SQLITE_NOMEM; + } + }while( sqlite3OsFileExists(zMaster) ); + + /* Open the master journal. */ + memset(&master, 0, sizeof(master)); + rc = sqlite3OsOpenExclusive(zMaster, &master, 0); + if( rc!=SQLITE_OK ){ + sqliteFree(zMaster); + return rc; + } + + /* Write the name of each database file in the transaction into the new + ** master journal file. If an error occurs at this point close + ** and delete the master journal file. All the individual journal files + ** still have 'null' as the master journal pointer, so they will roll + ** back independantly if a failure occurs. + */ + for(i=0; i<db->nDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( i==1 ) continue; /* Ignore the TEMP database */ + if( pBt && sqlite3BtreeIsInTrans(pBt) ){ + char const *zFile = sqlite3BtreeGetJournalname(pBt); + if( zFile[0]==0 ) continue; /* Ignore :memory: databases */ + rc = sqlite3OsWrite(&master, zFile, strlen(zFile)+1); + if( rc!=SQLITE_OK ){ + sqlite3OsClose(&master); + sqlite3OsDelete(zMaster); + sqliteFree(zMaster); + return rc; + } + } + } + + + /* Sync the master journal file. Before doing this, open the directory + ** the master journal file is store in so that it gets synced too. + */ + zMainFile = sqlite3BtreeGetDirname(db->aDb[0].pBt); + rc = sqlite3OsOpenDirectory(zMainFile, &master); + if( rc!=SQLITE_OK ){ + sqlite3OsClose(&master); + sqlite3OsDelete(zMaster); + sqliteFree(zMaster); + return rc; + } + rc = sqlite3OsSync(&master); + if( rc!=SQLITE_OK ){ + sqlite3OsClose(&master); + sqliteFree(zMaster); + return rc; + } + + /* Sync all the db files involved in the transaction. The same call + ** sets the master journal pointer in each individual journal. If + ** an error occurs here, do not delete the master journal file. + ** + ** If the error occurs during the first call to sqlite3BtreeSync(), + ** then there is a chance that the master journal file will be + ** orphaned. But we cannot delete it, in case the master journal + ** file name was written into the journal file before the failure + ** occured. + */ + for(i=0; i<db->nDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( pBt && sqlite3BtreeIsInTrans(pBt) ){ + rc = sqlite3BtreeSync(pBt, zMaster); + if( rc!=SQLITE_OK ){ + sqlite3OsClose(&master); + sqliteFree(zMaster); + return rc; + } + } + } + sqlite3OsClose(&master); + + /* Delete the master journal file. This commits the transaction. After + ** doing this the directory is synced again before any individual + ** transaction files are deleted. + */ + rc = sqlite3OsDelete(zMaster); + assert( rc==SQLITE_OK ); + sqliteFree(zMaster); + zMaster = 0; + rc = sqlite3OsSyncDirectory(zMainFile); + if( rc!=SQLITE_OK ){ + /* This is not good. The master journal file has been deleted, but + ** the directory sync failed. There is no completely safe course of + ** action from here. The individual journals contain the name of the + ** master journal file, but there is no way of knowing if that + ** master journal exists now or if it will exist after the operating + ** system crash that may follow the fsync() failure. + */ + assert(0); + sqliteFree(zMaster); + return rc; + } + + /* All files and directories have already been synced, so the following + ** calls to sqlite3BtreeCommit() are only closing files and deleting + ** journals. If something goes wrong while this is happening we don't + ** really care. The integrity of the transaction is already guaranteed, + ** but some stray 'cold' journals may be lying around. Returning an + ** error code won't help matters. + */ + for(i=0; i<db->nDb; i++){ + Btree *pBt = db->aDb[i].pBt; + if( pBt ){ + sqlite3BtreeCommit(pBt); + } + } + } + + return rc; +} + +/* +** Find every active VM other than pVdbe and change its status to +** aborted. This happens when one VM causes a rollback due to an +** ON CONFLICT ROLLBACK clause (for example). The other VMs must be +** aborted so that they do not have data rolled out from underneath +** them leading to a segfault. +*/ +static void abortOtherActiveVdbes(Vdbe *pVdbe){ + Vdbe *pOther; + for(pOther=pVdbe->db->pVdbe; pOther; pOther=pOther->pNext){ + if( pOther==pVdbe ) continue; + if( pOther->magic!=VDBE_MAGIC_RUN || pOther->pc<0 ) continue; + closeAllCursors(pOther); + pOther->aborted = 1; + } +} + +/* +** This routine checks that the sqlite3.activeVdbeCnt count variable +** matches the number of vdbe's in the list sqlite3.pVdbe that are +** currently active. An assertion fails if the two counts do not match. +** This is an internal self-check only - it is not an essential processing +** step. +** +** This is a no-op if NDEBUG is defined. +*/ +#ifndef NDEBUG +static void checkActiveVdbeCnt(sqlite3 *db){ + Vdbe *p; + int cnt = 0; + p = db->pVdbe; + while( p ){ + if( p->magic==VDBE_MAGIC_RUN && p->pc>=0 ){ + cnt++; + } + p = p->pNext; + } + assert( cnt==db->activeVdbeCnt ); +} +#else +#define checkActiveVdbeCnt(x) +#endif + +/* +** This routine is called the when a VDBE tries to halt. If the VDBE +** has made changes and is in autocommit mode, then commit those +** changes. If a rollback is needed, then do the rollback. +** +** This routine is the only way to move the state of a VM from +** SQLITE_MAGIC_RUN to SQLITE_MAGIC_HALT. +** +** Return an error code. If the commit could not complete because of +** lock contention, return SQLITE_BUSY. If SQLITE_BUSY is returned, it +** means the close did not happen and needs to be repeated. +*/ +int sqlite3VdbeHalt(Vdbe *p){ + sqlite3 *db = p->db; + int i; + int (*xFunc)(Btree *pBt) = 0; /* Function to call on each btree backend */ + + if( p->magic!=VDBE_MAGIC_RUN ){ + /* Already halted. Nothing to do. */ + assert( p->magic==VDBE_MAGIC_HALT ); + return SQLITE_OK; + } + closeAllCursors(p); + checkActiveVdbeCnt(db); + if( db->autoCommit && db->activeVdbeCnt==1 ){ + if( p->rc==SQLITE_OK || p->errorAction==OE_Fail ){ + /* The auto-commit flag is true, there are no other active queries + ** using this handle and the vdbe program was successful or hit an + ** 'OR FAIL' constraint. This means a commit is required. + */ + int rc = vdbeCommit(db); + if( rc==SQLITE_BUSY ){ + return SQLITE_BUSY; + }else if( rc!=SQLITE_OK ){ + p->rc = rc; + xFunc = sqlite3BtreeRollback; + } + }else{ + xFunc = sqlite3BtreeRollback; + } + }else{ + if( p->rc==SQLITE_OK || p->errorAction==OE_Fail ){ + xFunc = sqlite3BtreeCommitStmt; + }else if( p->errorAction==OE_Abort ){ + xFunc = sqlite3BtreeRollbackStmt; + }else{ + xFunc = sqlite3BtreeRollback; + db->autoCommit = 1; + abortOtherActiveVdbes(p); + } + } + + /* If xFunc is not NULL, then it is one of sqlite3BtreeRollback, + ** sqlite3BtreeRollbackStmt or sqlite3BtreeCommitStmt. Call it once on + ** each backend. If an error occurs and the return code is still + ** SQLITE_OK, set the return code to the new error value. + */ + for(i=0; xFunc && i<db->nDb; i++){ + int rc; + Btree *pBt = db->aDb[i].pBt; + if( pBt ){ + rc = xFunc(pBt); + if( p->rc==SQLITE_OK ) p->rc = rc; + } + } + + /* If this was an INSERT, UPDATE or DELETE, set the change counter. */ + if( p->changeCntOn ){ + if( !xFunc || xFunc==sqlite3BtreeCommitStmt ){ + sqlite3VdbeSetChanges(db, p->nChange); + }else{ + sqlite3VdbeSetChanges(db, 0); + } + p->nChange = 0; + } + + /* Rollback or commit any schema changes that occurred. */ + if( p->rc!=SQLITE_OK ){ + sqlite3RollbackInternalChanges(db); + }else if( db->flags & SQLITE_InternChanges ){ + sqlite3CommitInternalChanges(db); + } + + /* We have successfully halted and closed the VM. Record this fact. */ + if( p->pc>=0 ){ + db->activeVdbeCnt--; + } + p->magic = VDBE_MAGIC_HALT; + checkActiveVdbeCnt(db); + + return SQLITE_OK; +} + +/* +** Clean up a VDBE after execution but do not delete the VDBE just yet. +** Write any error messages into *pzErrMsg. Return the result code. +** +** After this routine is run, the VDBE should be ready to be executed +** again. +** +** To look at it another way, this routine resets the state of the +** virtual machine from VDBE_MAGIC_RUN or VDBE_MAGIC_HALT back to +** VDBE_MAGIC_INIT. +*/ +int sqlite3VdbeReset(Vdbe *p){ + if( p->magic!=VDBE_MAGIC_RUN && p->magic!=VDBE_MAGIC_HALT ){ + sqlite3Error(p->db, SQLITE_MISUSE, 0); + return SQLITE_MISUSE; + } + + /* If the VM did not run to completion or if it encountered an + ** error, then it might not have been halted properly. So halt + ** it now. + */ + sqlite3VdbeHalt(p); + + /* Transfer the error code and error message from the VDBE into the + ** main database structure. + */ + if( p->zErrMsg ){ + sqlite3Error(p->db, p->rc, "%s", p->zErrMsg); + sqliteFree(p->zErrMsg); + p->zErrMsg = 0; + }else if( p->rc ){ + sqlite3Error(p->db, p->rc, 0); + }else{ + sqlite3Error(p->db, SQLITE_OK, 0); + } + + /* Reclaim all memory used by the VDBE + */ + Cleanup(p); + + /* Save profiling information from this VDBE run. + */ + assert( p->pTos<&p->aStack[p->pc<0?0:p->pc] || sqlite3_malloc_failed==1 ); +#ifdef VDBE_PROFILE + { + FILE *out = fopen("vdbe_profile.out", "a"); + if( out ){ + int i; + fprintf(out, "---- "); + for(i=0; i<p->nOp; i++){ + fprintf(out, "%02x", p->aOp[i].opcode); + } + fprintf(out, "\n"); + for(i=0; i<p->nOp; i++){ + fprintf(out, "%6d %10lld %8lld ", + p->aOp[i].cnt, + p->aOp[i].cycles, + p->aOp[i].cnt>0 ? p->aOp[i].cycles/p->aOp[i].cnt : 0 + ); + sqlite3VdbePrintOp(out, i, &p->aOp[i]); + } + fclose(out); + } + } +#endif + p->magic = VDBE_MAGIC_INIT; + p->aborted = 0; + return p->rc; +} + +/* +** Clean up and delete a VDBE after execution. Return an integer which is +** the result code. Write any error message text into *pzErrMsg. +*/ +int sqlite3VdbeFinalize(Vdbe *p){ + int rc = SQLITE_OK; + sqlite3 *db = p->db; + + if( p->magic==VDBE_MAGIC_RUN || p->magic==VDBE_MAGIC_HALT ){ + rc = sqlite3VdbeReset(p); + }else if( p->magic!=VDBE_MAGIC_INIT ){ + /* sqlite3Error(p->db, SQLITE_MISUSE, 0); */ + return SQLITE_MISUSE; + } + sqlite3VdbeDelete(p); + if( rc==SQLITE_SCHEMA ){ + sqlite3ResetInternalSchema(db, 0); + } + return rc; +} + +/* +** Call the destructor for each auxdata entry in pVdbeFunc for which +** the corresponding bit in mask is clear. Auxdata entries beyond 31 +** are always destroyed. To destroy all auxdata entries, call this +** routine with mask==0. +*/ +void sqlite3VdbeDeleteAuxData(VdbeFunc *pVdbeFunc, int mask){ + int i; + for(i=0; i<pVdbeFunc->nAux; i++){ + struct AuxData *pAux = &pVdbeFunc->apAux[i]; + if( (i>31 || !(mask&(1<<i))) && pAux->pAux ){ + if( pAux->xDelete ){ + pAux->xDelete(pAux->pAux); + } + pAux->pAux = 0; + } + } +} + +/* +** Delete an entire VDBE. +*/ +void sqlite3VdbeDelete(Vdbe *p){ + int i; + if( p==0 ) return; + Cleanup(p); + if( p->pPrev ){ + p->pPrev->pNext = p->pNext; + }else{ + assert( p->db->pVdbe==p ); + p->db->pVdbe = p->pNext; + } + if( p->pNext ){ + p->pNext->pPrev = p->pPrev; + } + if( p->aOp ){ + for(i=0; i<p->nOp; i++){ + Op *pOp = &p->aOp[i]; + if( pOp->p3type==P3_DYNAMIC || pOp->p3type==P3_KEYINFO ){ + sqliteFree(pOp->p3); + } + if( pOp->p3type==P3_VDBEFUNC ){ + VdbeFunc *pVdbeFunc = (VdbeFunc *)pOp->p3; + sqlite3VdbeDeleteAuxData(pVdbeFunc, 0); + sqliteFree(pVdbeFunc); + } + } + sqliteFree(p->aOp); + } + releaseMemArray(p->aVar, p->nVar); + sqliteFree(p->aLabel); + sqliteFree(p->aStack); + releaseMemArray(p->aColName, p->nResColumn*2); + sqliteFree(p->aColName); + p->magic = VDBE_MAGIC_DEAD; + sqliteFree(p); +} + +/* +** If a MoveTo operation is pending on the given cursor, then do that +** MoveTo now. Return an error code. If no MoveTo is pending, this +** routine does nothing and returns SQLITE_OK. +*/ +int sqlite3VdbeCursorMoveto(Cursor *p){ + if( p->deferredMoveto ){ + int res; + extern int sqlite3_search_count; + assert( p->intKey ); + if( p->intKey ){ + sqlite3BtreeMoveto(p->pCursor, 0, p->movetoTarget, &res); + }else{ + sqlite3BtreeMoveto(p->pCursor,(char*)&p->movetoTarget,sizeof(i64),&res); + } + *p->pIncrKey = 0; + p->lastRecno = keyToInt(p->movetoTarget); + p->recnoIsValid = res==0; + if( res<0 ){ + sqlite3BtreeNext(p->pCursor, &res); + } + sqlite3_search_count++; + p->deferredMoveto = 0; + p->cacheValid = 0; + } + return SQLITE_OK; +} + +/* +** The following functions: +** +** sqlite3VdbeSerialType() +** sqlite3VdbeSerialTypeLen() +** sqlite3VdbeSerialRead() +** sqlite3VdbeSerialLen() +** sqlite3VdbeSerialWrite() +** +** encapsulate the code that serializes values for storage in SQLite +** data and index records. Each serialized value consists of a +** 'serial-type' and a blob of data. The serial type is an 8-byte unsigned +** integer, stored as a varint. +** +** In an SQLite index record, the serial type is stored directly before +** the blob of data that it corresponds to. In a table record, all serial +** types are stored at the start of the record, and the blobs of data at +** the end. Hence these functions allow the caller to handle the +** serial-type and data blob seperately. +** +** The following table describes the various storage classes for data: +** +** serial type bytes of data type +** -------------- --------------- --------------- +** 0 0 NULL +** 1 1 signed integer +** 2 2 signed integer +** 3 3 signed integer +** 4 4 signed integer +** 5 6 signed integer +** 6 8 signed integer +** 7 8 IEEE float +** 8-11 reserved for expansion +** N>=12 and even (N-12)/2 BLOB +** N>=13 and odd (N-13)/2 text +** +*/ + +/* +** Return the serial-type for the value stored in pMem. +*/ +u32 sqlite3VdbeSerialType(Mem *pMem){ + int flags = pMem->flags; + + if( flags&MEM_Null ){ + return 0; + } + if( flags&MEM_Int ){ + /* Figure out whether to use 1, 2, 4 or 8 bytes. */ + i64 i = pMem->i; + if( i>=-127 && i<=127 ) return 1; + if( i>=-32767 && i<=32767 ) return 2; + if( i>=-8388607 && i<=8388607 ) return 3; + if( i>=-2147483647 && i<=2147483647 ) return 4; + if( i>=-140737488355328L && i<=140737488355328L ) return 5; + return 6; + } + if( flags&MEM_Real ){ + return 7; + } + if( flags&MEM_Str ){ + int n = pMem->n; + assert( n>=0 ); + return ((n*2) + 13); + } + if( flags&MEM_Blob ){ + return (pMem->n*2 + 12); + } + return 0; +} + +/* +** Return the length of the data corresponding to the supplied serial-type. +*/ +int sqlite3VdbeSerialTypeLen(u32 serial_type){ + if( serial_type>=12 ){ + return (serial_type-12)/2; + }else{ + static const u8 aSize[] = { 0, 1, 2, 3, 4, 6, 8, 8, 0, 0, 0, 0 }; + return aSize[serial_type]; + } +} + +/* +** Write the serialized data blob for the value stored in pMem into +** buf. It is assumed that the caller has allocated sufficient space. +** Return the number of bytes written. +*/ +int sqlite3VdbeSerialPut(unsigned char *buf, Mem *pMem){ + u32 serial_type = sqlite3VdbeSerialType(pMem); + int len; + + /* NULL */ + if( serial_type==0 ){ + return 0; + } + + /* Integer and Real */ + if( serial_type<=7 ){ + u64 v; + int i; + if( serial_type==7 ){ + v = *(u64*)&pMem->r; + }else{ + v = *(u64*)&pMem->i; + } + len = i = sqlite3VdbeSerialTypeLen(serial_type); + while( i-- ){ + buf[i] = (v&0xFF); + v >>= 8; + } + return len; + } + + /* String or blob */ + assert( serial_type>=12 ); + len = sqlite3VdbeSerialTypeLen(serial_type); + memcpy(buf, pMem->z, len); + return len; +} + +/* +** Deserialize the data blob pointed to by buf as serial type serial_type +** and store the result in pMem. Return the number of bytes read. +*/ +int sqlite3VdbeSerialGet( + const unsigned char *buf, /* Buffer to deserialize from */ + u32 serial_type, /* Serial type to deserialize */ + Mem *pMem /* Memory cell to write value into */ +){ + int len; + + if( serial_type==0 ){ + /* NULL */ + pMem->flags = MEM_Null; + return 0; + } + len = sqlite3VdbeSerialTypeLen(serial_type); + if( serial_type<=7 ){ + /* Integer and Real */ + if( serial_type<=4 ){ + /* 32-bit integer type. This is handled by a special case for + ** performance reasons. */ + int v = buf[0]; + int n; + if( v&0x80 ){ + v |= -256; + } + for(n=1; n<len; n++){ + v = (v<<8) | buf[n]; + } + pMem->flags = MEM_Int; + pMem->i = v; + return n; + }else{ + u64 v = 0; + int n; + + if( buf[0]&0x80 ){ + v = -1; + } + for(n=0; n<len; n++){ + v = (v<<8) | buf[n]; + } + if( serial_type==7 ){ + pMem->flags = MEM_Real; + pMem->r = *(double*)&v; + }else{ + pMem->flags = MEM_Int; + pMem->i = *(i64*)&v; + } + } + }else{ + /* String or blob */ + assert( serial_type>=12 ); + pMem->z = (char *)buf; + pMem->n = len; + pMem->xDel = 0; + if( serial_type&0x01 ){ + pMem->flags = MEM_Str | MEM_Ephem; + }else{ + pMem->flags = MEM_Blob | MEM_Ephem; + } + } + return len; +} + +/* +** This function compares the two table rows or index records specified by +** {nKey1, pKey1} and {nKey2, pKey2}, returning a negative, zero +** or positive integer if {nKey1, pKey1} is less than, equal to or +** greater than {nKey2, pKey2}. Both Key1 and Key2 must be byte strings +** composed by the OP_MakeRecord opcode of the VDBE. +*/ +int sqlite3VdbeRecordCompare( + void *userData, + int nKey1, const void *pKey1, + int nKey2, const void *pKey2 +){ + KeyInfo *pKeyInfo = (KeyInfo*)userData; + u32 d1, d2; /* Offset into aKey[] of next data element */ + u32 idx1, idx2; /* Offset into aKey[] of next header element */ + u32 szHdr1, szHdr2; /* Number of bytes in header */ + int i = 0; + int nField; + int rc = 0; + const unsigned char *aKey1 = (const unsigned char *)pKey1; + const unsigned char *aKey2 = (const unsigned char *)pKey2; + + Mem mem1; + Mem mem2; + mem1.enc = pKeyInfo->enc; + mem2.enc = pKeyInfo->enc; + + idx1 = sqlite3GetVarint32(pKey1, &szHdr1); + d1 = szHdr1; + idx2 = sqlite3GetVarint32(pKey2, &szHdr2); + d2 = szHdr2; + nField = pKeyInfo->nField; + while( idx1<szHdr1 && idx2<szHdr2 ){ + u32 serial_type1; + u32 serial_type2; + + /* Read the serial types for the next element in each key. */ + idx1 += sqlite3GetVarint32(&aKey1[idx1], &serial_type1); + if( d1>=nKey1 && sqlite3VdbeSerialTypeLen(serial_type1)>0 ) break; + idx2 += sqlite3GetVarint32(&aKey2[idx2], &serial_type2); + if( d2>=nKey2 && sqlite3VdbeSerialTypeLen(serial_type2)>0 ) break; + + /* Assert that there is enough space left in each key for the blob of + ** data to go with the serial type just read. This assert may fail if + ** the file is corrupted. Then read the value from each key into mem1 + ** and mem2 respectively. + */ + d1 += sqlite3VdbeSerialGet(&aKey1[d1], serial_type1, &mem1); + d2 += sqlite3VdbeSerialGet(&aKey2[d2], serial_type2, &mem2); + + rc = sqlite3MemCompare(&mem1, &mem2, i<nField ? pKeyInfo->aColl[i] : 0); + sqlite3VdbeMemRelease(&mem1); + sqlite3VdbeMemRelease(&mem2); + if( rc!=0 ){ + break; + } + i++; + } + + /* One of the keys ran out of fields, but all the fields up to that point + ** were equal. If the incrKey flag is true, then the second key is + ** treated as larger. + */ + if( rc==0 ){ + if( pKeyInfo->incrKey ){ + rc = -1; + }else if( d1<nKey1 ){ + rc = 1; + }else if( d2<nKey2 ){ + rc = -1; + } + } + + if( pKeyInfo->aSortOrder && i<pKeyInfo->nField && pKeyInfo->aSortOrder[i] ){ + rc = -rc; + } + + return rc; +} + +/* +** The argument is an index entry composed using the OP_MakeRecord opcode. +** The last entry in this record should be an integer (specifically +** an integer rowid). This routine returns the number of bytes in +** that integer. +*/ +int sqlite3VdbeIdxRowidLen(int nKey, const u8 *aKey){ + u32 szHdr; /* Size of the header */ + u32 typeRowid; /* Serial type of the rowid */ + + sqlite3GetVarint32(aKey, &szHdr); + sqlite3GetVarint32(&aKey[szHdr-1], &typeRowid); + return sqlite3VdbeSerialTypeLen(typeRowid); +} + + +/* +** pCur points at an index entry created using the OP_MakeRecord opcode. +** Read the rowid (the last field in the record) and store it in *rowid. +** Return SQLITE_OK if everything works, or an error code otherwise. +*/ +int sqlite3VdbeIdxRowid(BtCursor *pCur, i64 *rowid){ + i64 nCellKey; + int rc; + u32 szHdr; /* Size of the header */ + u32 typeRowid; /* Serial type of the rowid */ + u32 lenRowid; /* Size of the rowid */ + Mem m, v; + + sqlite3BtreeKeySize(pCur, &nCellKey); + if( nCellKey<=0 ){ + return SQLITE_CORRUPT; + } + rc = sqlite3VdbeMemFromBtree(pCur, 0, nCellKey, 1, &m); + if( rc ){ + return rc; + } + sqlite3GetVarint32(m.z, &szHdr); + sqlite3GetVarint32(&m.z[szHdr-1], &typeRowid); + lenRowid = sqlite3VdbeSerialTypeLen(typeRowid); + sqlite3VdbeSerialGet(&m.z[m.n-lenRowid], typeRowid, &v); + *rowid = v.i; + sqlite3VdbeMemRelease(&m); + return SQLITE_OK; +} + +/* +** Compare the key of the index entry that cursor pC is point to against +** the key string in pKey (of length nKey). Write into *pRes a number +** that is negative, zero, or positive if pC is less than, equal to, +** or greater than pKey. Return SQLITE_OK on success. +** +** pKey is either created without a rowid or is truncated so that it +** omits the rowid at the end. The rowid at the end of the index entry +** is ignored as well. +*/ +int sqlite3VdbeIdxKeyCompare( + Cursor *pC, /* The cursor to compare against */ + int nKey, const u8 *pKey, /* The key to compare */ + int *res /* Write the comparison result here */ +){ + i64 nCellKey; + int rc; + BtCursor *pCur = pC->pCursor; + int lenRowid; + Mem m; + + sqlite3BtreeKeySize(pCur, &nCellKey); + if( nCellKey<=0 ){ + *res = 0; + return SQLITE_OK; + } + rc = sqlite3VdbeMemFromBtree(pC->pCursor, 0, nCellKey, 1, &m); + if( rc ){ + return rc; + } + lenRowid = sqlite3VdbeIdxRowidLen(m.n, m.z); + *res = sqlite3VdbeRecordCompare(pC->pKeyInfo, m.n-lenRowid, m.z, nKey, pKey); + sqlite3VdbeMemRelease(&m); + return SQLITE_OK; +} + +/* +** This routine sets the value to be returned by subsequent calls to +** sqlite3_changes() on the database handle 'db'. +*/ +void sqlite3VdbeSetChanges(sqlite3 *db, int nChange){ + db->nChange = nChange; + db->nTotalChange += nChange; +} + +/* +** Set a flag in the vdbe to update the change counter when it is finalised +** or reset. +*/ +void sqlite3VdbeCountChanges(Vdbe *p){ + p->changeCntOn = 1; +} |