Lines Matching refs:Mem
3647 typedef struct Mem sqlite3_value;
10303 typedef struct Mem Mem;
10328 Mem *pMem; /* Used when p4type is P4_MEM */
10383 #define P4_MEM (-8) /* P4 is a pointer to a Mem* structure */
10402 ** The Vdbe.aColName array contains 5n Mem structures, where n is the
10689 SQLITE_PRIVATE int sqlite3MemCompare(const Mem*, const Mem*, const CollSeq*);
12379 Mem *aMem; /* Values */
15385 Mem *aMem; /* Array of memory cells for parent frame */
15401 #define VdbeFrameMem(p) ((Mem *)&((u8 *)p)[ROUND8(sizeof(VdbeFrame))])
15409 ** Internally, the vdbe manipulates nearly all SQL values as Mem
15410 ** structures. Each Mem struct may cache multiple representations (string,
15413 struct Mem {
15432 void (*xDel)(void*);/* Destructor for Mem.z - only valid if MEM_Dyn */
15434 Mem *pScopyFrom; /* This Mem is a shallow copy of pScopyFrom */
15435 void *pFiller; /* So that sizeof(Mem) is a multiple of 8 */
15440 ** Size of struct Mem not including the Mem.zMalloc member or anything that
15443 #define MEMCELLSIZE offsetof(Mem,zMalloc)
15446 ** representations of the value stored in the Mem struct.
15451 ** If the MEM_Str flag is set then Mem.z points at a string representation.
15470 /* Whenever Mem contains a valid string or blob representation, one of
15472 ** policy for Mem.z. The MEM_Term flag tells us whether or not the
15476 #define MEM_Dyn 0x0400 /* Need to call Mem.xDel() on Mem.z */
15477 #define MEM_Static 0x0800 /* Mem.z points to a static string */
15478 #define MEM_Ephem 0x1000 /* Mem.z points to an ephemeral string */
15479 #define MEM_Agg 0x2000 /* Mem.z points to an agg function context */
15480 #define MEM_Zero 0x4000 /* Mem.i contains count of 0s appended to blob */
15487 ** Clear any existing type flags from a Mem and replace them with f
15526 ** (Mem) which are only defined there.
15529 Mem *pOut; /* The return value is stored here */
15531 Mem *pMem; /* Memory cell used to store aggregate context */
15578 Mem *aMem; /* The memory locations */
15579 Mem **apArg; /* Arguments to currently executing user function */
15580 Mem *aColName; /* Column names to return */
15581 Mem *pResultSet; /* Pointer to an array of results */
15590 Mem *aVar; /* Values for the OP_Variable opcode. */
15661 SQLITE_PRIVATE u32 sqlite3VdbeSerialType(Mem*, int);
15662 SQLITE_PRIVATE u32 sqlite3VdbeSerialPut(unsigned char*, Mem*, u32);
15663 SQLITE_PRIVATE u32 sqlite3VdbeSerialGet(const unsigned char*, u32, Mem*);
15672 SQLITE_PRIVATE int sqlite3VdbeChangeEncoding(Mem *, int);
15673 SQLITE_PRIVATE int sqlite3VdbeMemTooBig(Mem*);
15674 SQLITE_PRIVATE int sqlite3VdbeMemCopy(Mem*, const Mem*);
15675 SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem*, const Mem*, int);
15676 SQLITE_PRIVATE void sqlite3VdbeMemMove(Mem*, Mem*);
15677 SQLITE_PRIVATE int sqlite3VdbeMemNulTerminate(Mem*);
15678 SQLITE_PRIVATE int sqlite3VdbeMemSetStr(Mem*, const char*, int, u8, void(*)(void*));
15679 SQLITE_PRIVATE void sqlite3VdbeMemSetInt64(Mem*, i64);
15683 SQLITE_PRIVATE void sqlite3VdbeMemSetDouble(Mem*, double);
15685 SQLITE_PRIVATE void sqlite3VdbeMemInit(Mem*,sqlite3*,u16);
15686 SQLITE_PRIVATE void sqlite3VdbeMemSetNull(Mem*);
15687 SQLITE_PRIVATE void sqlite3VdbeMemSetZeroBlob(Mem*,int);
15688 SQLITE_PRIVATE void sqlite3VdbeMemSetRowSet(Mem*);
15689 SQLITE_PRIVATE int sqlite3VdbeMemMakeWriteable(Mem*);
15690 SQLITE_PRIVATE int sqlite3VdbeMemStringify(Mem*, u8, u8);
15691 SQLITE_PRIVATE i64 sqlite3VdbeIntValue(Mem*);
15692 SQLITE_PRIVATE int sqlite3VdbeMemIntegerify(Mem*);
15693 SQLITE_PRIVATE double sqlite3VdbeRealValue(Mem*);
15694 SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem*);
15695 SQLITE_PRIVATE int sqlite3VdbeMemRealify(Mem*);
15696 SQLITE_PRIVATE int sqlite3VdbeMemNumerify(Mem*);
15697 SQLITE_PRIVATE void sqlite3VdbeMemCast(Mem*,u8,u8);
15698 SQLITE_PRIVATE int sqlite3VdbeMemFromBtree(BtCursor*,u32,u32,int,Mem*);
15699 SQLITE_PRIVATE void sqlite3VdbeMemRelease(Mem *p);
15702 SQLITE_PRIVATE int sqlite3VdbeMemFinalize(Mem*, FuncDef*);
15704 SQLITE_PRIVATE int sqlite3VdbeMemGrow(Mem *pMem, int n, int preserve);
15705 SQLITE_PRIVATE int sqlite3VdbeMemClearAndResize(Mem *pMem, int n);
15714 SQLITE_PRIVATE int sqlite3VdbeSorterRowkey(const VdbeCursor *, Mem *);
15717 SQLITE_PRIVATE int sqlite3VdbeSorterWrite(const VdbeCursor *, Mem *);
15718 SQLITE_PRIVATE int sqlite3VdbeSorterCompare(const VdbeCursor *, Mem *, int, int *);
15729 SQLITE_PRIVATE void sqlite3VdbeMemAboutToChange(Vdbe*,Mem*);
15730 SQLITE_PRIVATE int sqlite3VdbeCheckMemInvariants(Mem*);
15739 SQLITE_PRIVATE int sqlite3VdbeMemTranslate(Mem*, u8);
15742 SQLITE_PRIVATE void sqlite3VdbeMemPrettyPrint(Mem *pMem, char *zBuf);
15744 SQLITE_PRIVATE int sqlite3VdbeMemHandleBom(Mem *pMem);
15747 SQLITE_PRIVATE int sqlite3VdbeMemExpandBlob(Mem *);
18150 ** into a single structure named "mem". This is to keep the
18195 } mem;
18207 mem.nAlloc[i]++;
18208 mem.nCurrent[i]++;
18209 if( mem.nCurrent[i]>mem.mxCurrent[i] ){
18210 mem.mxCurrent[i] = mem.nCurrent[i];
18213 mem.nCurrent[i]--;
18214 assert( mem.nCurrent[i]>=0 );
18266 mem.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
18276 mem.mutex = 0;
18322 sqlite3_mutex_enter(mem.mutex);
18323 assert( mem.disallow==0 );
18326 mem.nBacktrace*sizeof(void*) + mem.nTitle;
18330 pBt = (void**)&z[mem.nTitle];
18331 pHdr = (struct MemBlockHdr*)&pBt[mem.nBacktrace];
18333 pHdr->pPrev = mem.pLast;
18334 if( mem.pLast ){
18335 mem.pLast->pNext = pHdr;
18337 mem.pFirst = pHdr;
18339 mem.pLast = pHdr;
18342 pHdr->nBacktraceSlots = mem.nBacktrace;
18343 pHdr->nTitle = mem.nTitle;
18344 if( mem.nBacktrace ){
18346 pHdr->nBacktrace = backtrace(aAddr, mem.nBacktrace+1)-1;
18349 if( mem.xBacktrace ){
18350 mem.xBacktrace(nByte, pHdr->nBacktrace-1, &aAddr[1]);
18355 if( mem.nTitle ){
18356 memcpy(z, mem.zTitle, mem.nTitle);
18366 sqlite3_mutex_leave(mem.mutex);
18378 || mem.mutex!=0 );
18382 sqlite3_mutex_enter(mem.mutex);
18387 assert( mem.pFirst==pHdr );
18388 mem.pFirst = pHdr->pNext;
18394 assert( mem.pLast==pHdr );
18395 mem.pLast = pHdr->pPrev;
18403 sqlite3_mutex_leave(mem.mutex);
18418 assert( mem.disallow==0 );
18515 mem.nBacktrace = depth;
18519 mem.xBacktrace = xBacktrace;
18527 sqlite3_mutex_enter(mem.mutex);
18528 if( n>=sizeof(mem.zTitle) ) n = sizeof(mem.zTitle)-1;
18529 memcpy(mem.zTitle, zTitle, n);
18530 mem.zTitle[n] = 0;
18531 mem.nTitle = ROUND8(n);
18532 sqlite3_mutex_leave(mem.mutex);
18537 for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){
18540 mem.xBacktrace((int)pHdr->iSize, pHdr->nBacktrace-1, &pBt[1]);
18559 for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){
18574 if( mem.nAlloc[i] ){
18576 i*8, mem.nAlloc[i], mem.nCurrent[i], mem.mxCurrent[i]);
18579 if( mem.nAlloc[NCSIZE-1] ){
18581 NCSIZE*8-8, mem.nAlloc[NCSIZE-1],
18582 mem.nCurrent[NCSIZE-1], mem.mxCurrent[NCSIZE-1]);
18594 nTotal += mem.nAlloc[i];
24236 ** If the TRANSLATE_TRACE macro is defined, the value of each Mem is
24247 SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3VdbeMemTranslate(Mem *pMem, u8 desiredEnc){
24384 ** the encoding of the Mem adjusted. This routine does not do any
24385 ** byte-swapping, it just sets Mem.enc appropriately.
24387 ** The allocation (static, dynamic etc.) and encoding of the Mem may be
24390 SQLITE_PRIVATE int sqlite3VdbeMemHandleBom(Mem *pMem){
24483 Mem m;
64973 ** This file contains code use to manipulate "Mem" structure. A "Mem"
64974 ** stores a single value in the VDBE. Mem is an opaque structure visible
64975 ** only within the VDBE. Interface routines refer to a Mem using the
64983 ** Check invariants on a Mem object.
64988 SQLITE_PRIVATE int sqlite3VdbeCheckMemInvariants(Mem *p){
64989 /* If MEM_Dyn is set then Mem.xDel!=0.
64990 ** Mem.xDel is might not be initialized if MEM_Dyn is clear.
64994 /* MEM_Dyn may only be set if Mem.szMalloc==0. In this way we
64995 ** ensure that if Mem.szMalloc>0 then it is safe to do
64996 ** Mem.z = Mem.zMalloc without having to check Mem.flags&MEM_Dyn.
65007 /* If p holds a string or blob, the Mem.z must point to exactly
65010 ** (1) Memory in Mem.zMalloc and managed by the Mem object
65011 ** (2) Memory to be freed using Mem.xDel
65041 SQLITE_PRIVATE int sqlite3VdbeChangeEncoding(Mem *pMem, int desiredEnc){
65076 SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3VdbeMemGrow(Mem *pMem, int n, int bPreserve){
65132 SQLITE_PRIVATE int sqlite3VdbeMemClearAndResize(Mem *pMem, int szNew){
65146 ** MEM.zMalloc, where it can be safely written.
65150 SQLITE_PRIVATE int sqlite3VdbeMemMakeWriteable(Mem *pMem){
65173 ** If the given Mem* has a zero-filled tail, turn it into an ordinary
65177 SQLITE_PRIVATE int sqlite3VdbeMemExpandBlob(Mem *pMem){
65205 static SQLITE_NOINLINE int vdbeMemAddTerminator(Mem *pMem){
65216 ** Make sure the given Mem is \u0000 terminated.
65218 SQLITE_PRIVATE int sqlite3VdbeMemNulTerminate(Mem *pMem){
65230 ** Add MEM_Str to the set of representations for the given Mem. Numbers
65243 SQLITE_PRIVATE int sqlite3VdbeMemStringify(Mem *pMem, u8 enc, u8 bForce){
65287 SQLITE_PRIVATE int sqlite3VdbeMemFinalize(Mem *pMem, FuncDef *pFunc){
65291 Mem t;
65312 ** invoking the external callback in Mem.xDel, then this routine
65313 ** will free that value. It also sets Mem.flags to MEM_Null.
65317 ** entry point for releasing Mem resources.
65319 static SQLITE_NOINLINE void vdbeMemClearExternAndSetNull(Mem *p){
65342 ** Release memory held by the Mem p, both external memory cleared
65349 static SQLITE_NOINLINE void vdbeMemClear(Mem *p){
65361 ** Release any memory resources held by the Mem. Both the memory that is
65362 ** free by Mem.xDel and the Mem.zMalloc allocation are freed.
65364 ** Use this routine prior to clean up prior to abandoning a Mem
65365 ** reset a Mem back to its minimum memory utilization.
65367 ** Use sqlite3VdbeMemSetNull() to release just the Mem.xDel space
65368 ** prior to inserting new content into the Mem.
65370 SQLITE_PRIVATE void sqlite3VdbeMemRelease(Mem *p){
65418 SQLITE_PRIVATE i64 sqlite3VdbeIntValue(Mem *pMem){
65443 SQLITE_PRIVATE double sqlite3VdbeRealValue(Mem *pMem){
65462 ** The MEM structure is already a MEM_Real. Try to also make it a
65465 SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem *pMem){
65493 SQLITE_PRIVATE int sqlite3VdbeMemIntegerify(Mem *pMem){
65507 SQLITE_PRIVATE int sqlite3VdbeMemRealify(Mem *pMem){
65524 SQLITE_PRIVATE int sqlite3VdbeMemNumerify(Mem *pMem){
65548 SQLITE_PRIVATE void sqlite3VdbeMemCast(Mem *pMem, u8 aff, u8 encoding){
65586 ** Initialize bulk memory to be a consistent Mem object.
65590 SQLITE_PRIVATE void sqlite3VdbeMemInit(Mem *pMem, sqlite3 *db, u16 flags){
65601 ** This routine calls the Mem.xDel destructor to dispose of values that
65602 ** require the destructor. But it preserves the Mem.zMalloc memory allocation.
65604 ** routine to invoke the destructor and deallocates Mem.zMalloc.
65606 ** Use this routine to reset the Mem prior to insert a new value.
65608 ** Use sqlite3VdbeMemRelease() to complete erase the Mem prior to abandoning it.
65610 SQLITE_PRIVATE void sqlite3VdbeMemSetNull(Mem *pMem){
65618 sqlite3VdbeMemSetNull((Mem*)p);
65625 SQLITE_PRIVATE void sqlite3VdbeMemSetZeroBlob(Mem *pMem, int n){
65640 static SQLITE_NOINLINE void vdbeReleaseAndSetInt64(Mem *pMem, i64 val){
65650 SQLITE_PRIVATE void sqlite3VdbeMemSetInt64(Mem *pMem, i64 val){
65664 SQLITE_PRIVATE void sqlite3VdbeMemSetDouble(Mem *pMem, double val){
65677 SQLITE_PRIVATE void sqlite3VdbeMemSetRowSet(Mem *pMem){
65696 ** Return true if the Mem object contains a TEXT or BLOB that is
65699 SQLITE_PRIVATE int sqlite3VdbeMemTooBig(Mem *p){
65720 SQLITE_PRIVATE void sqlite3VdbeMemAboutToChange(Vdbe *pVdbe, Mem *pMem){
65722 Mem *pX;
65740 static SQLITE_NOINLINE void vdbeClrCopy(Mem *pTo, const Mem *pFrom, int eType){
65745 SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int srcType){
65761 SQLITE_PRIVATE int sqlite3VdbeMemCopy(Mem *pTo, const Mem *pFrom){
65788 SQLITE_PRIVATE void sqlite3VdbeMemMove(Mem *pTo, Mem *pFrom){
65794 memcpy(pTo, pFrom, sizeof(Mem));
65800 ** Change the value of a Mem to be a string or a BLOB.
65805 ** Mem structure. Otherwise, any existing buffer is freed and the
65815 Mem *pMem, /* Memory cell to set to string value */
65851 /* The following block sets the new values of Mem.z and Mem.xDel. It
65899 Mem structure.
65919 Mem *pMem /* OUT: Return data in this Mem structure. */
65945 Mem *pMem /* OUT: Return data in this Mem structure. */
66042 Mem *p = sqlite3DbMallocZero(db, sizeof(*p));
66083 nByte = sizeof(Mem) * nCol + ROUND8(sizeof(UnpackedRecord));
66090 pRec->aMem = (Mem *)((u8*)pRec + ROUND8(sizeof(UnpackedRecord)));
66466 sqlite3VdbeMemSetNull((Mem*)pVal);
66477 rc = sqlite3VdbeMemCopy((Mem*)pVal, &v->aVar[iBindVar-1]);
66588 Mem *pMem = *ppVal; /* Write result into this Mem object */
66623 Mem *aMem = pRec->aMem;
66644 if( v ) sqlite3VdbeMemSetStr((Mem *)v, z, n, enc, xDel);
66652 sqlite3VdbeMemRelease((Mem *)v);
66653 sqlite3DbFree(((Mem*)v)->db, v);
66665 Mem *p = (Mem*)pVal;
67460 Mem *p = (Mem*)p4;
67842 Mem *pMem = pOp->p4.pMem;
67997 ** Release an array of N Mem elements
67999 static void releaseMemArray(Mem *p, int N){
68001 Mem *pEnd = &p[N];
68049 Mem *aMem = VdbeFrameMem(p);
68080 Mem *pSub = 0; /* Memory cell hold array of subprogs */
68084 Mem *pMem = &p->aMem[1]; /* First Mem of result set */
68464 p->aMem = allocSpace(p->aMem, nMem*sizeof(Mem), &zCsr, zEnd, &nByte);
68465 Mem), &zCsr, zEnd, &nByte);
68466 p->apArg = allocSpace(p->apArg, nArg*sizeof(Mem*), &zCsr, zEnd, &nByte);
68635 Mem *pColName;
68643 p->aColName = pColName = (Mem*)sqlite3DbMallocZero(db, sizeof(Mem)*n );
68670 Mem *pColName;
69625 SQLITE_PRIVATE u32 sqlite3VdbeSerialType(Mem *pMem, int file_format){
69747 SQLITE_PRIVATE u32 sqlite3VdbeSerialPut(u8 *buf, Mem *pMem, u32 serial_type){
69804 Mem *pMem /* Memory cell to write value into */
69840 Mem *pMem /* Memory cell to write value into */
69947 nByte = ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*(pKeyInfo->nField+1);
69957 p->aMem = (Mem
69980 Mem *pMem = p->aMem;
70027 Mem mem1;
70151 const Mem *pMem1,
70152 const Mem *pMem2,
70164 Mem c1;
70165 Mem c2;
70187 static SQLITE_NOINLINE int sqlite3BlobCompare(const Mem *pB1, const Mem *pB2){
70203 SQLITE_PRIVATE int sqlite3MemCompare(const Mem *pMem1, const Mem *pMem2, const CollSeq *pColl){
70354 Mem *pRhs = pPKey2->aMem; /* Next field of pPKey2 to compare */
70357 Mem mem1;
70750 Mem m, v;
70831 Mem m;
70905 Mem *pMem = &v->aVar[iVar-1];
70909 sqlite3VdbeMemCopy((Mem *)pRet, pMem);
71107 ** The following routines extract information from a Mem or sqlite3_value
71111 Mem *p = (Mem*)pVal;
71130 return sqlite3VdbeRealValue((Mem*)pVal);
71133 return (int)sqlite3VdbeIntValue((Mem*)pVal);
71136 return sqlite3VdbeIntValue((Mem*)pVal);
71139 return ((Mem*)pVal)->eSubtype;
71386 Mem *pOut = pCtx->pOut;
71708 Mem *pMem = p->pMem;
71847 static const Mem *columnNullValue(void){
71848 /* Even though the Mem structure contains an element
71850 ** switches (-Os), gcc may align this Mem object on a 4-byte boundary
71853 ** that a Mem structure is located on an 8-byte boundary. To prevent
71857 static const Mem nullMem
71874 /* .pScopyFrom = */ (Mem*)0,
71883 ** it is, return a pointer to the Mem for the value of that column.
71884 ** If iCol is not valid, return a pointer to a Mem which has a value
71887 static Mem *columnMem(sqlite3_stmt *pStmt, int i){
71889 Mem *pOut;
71900 pOut = (Mem*)columnNullValue();
71982 Mem *pOut = columnMem(pStmt, i);
72022 const void *(*xFunc)(Mem*),
72063 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_NAME);
72068 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_NAME);
72088 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DECLTYPE);
72093 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DECLTYPE);
72106 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DATABASE);
72111 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DATABASE);
72122 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_TABLE);
72127 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_TABLE);
72138 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_COLUMN);
72143 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_COLUMN);
72165 Mem *pVar;
72217 Mem *pVar;
72701 Mem *pVar; /* Value of a host parameter */
72757 Mem utf8;
72892 static void updateMaxBlobsize(Mem *p){
73009 Mem *pMem = &p->aMem[p->nMem-iCur];
73052 static void applyNumericAffinity(Mem *pRec, int bTryForInt){
73087 Mem *pRec, /* The value to apply affinity to */
73122 Mem *pMem = (Mem*)pVal;
73131 ** not the internal Mem* type.
73138 applyAffinity((Mem *)pVal, affinity, enc);
73147 static u16 SQLITE_NOINLINE computeNumericType(Mem *pMem){
73166 static u16 numericType(Mem *pMem){
73181 SQLITE_PRIVATE void sqlite3VdbeMemPrettyPrint(Mem *pMem, char *zBuf){
73263 static void memTracePrint(Mem *p){
73284 static void registerTrace(int iReg, Mem *p){
73421 static Mem *out2Prerelease(Vdbe *p, VdbeOp *pOp){
73422 Mem *pOut;
73454 Mem *aMem = p->aMem; /* Copy of p->aMem */
73455 Mem *pIn1 = 0; /* 1st input operand */
73456 Mem *pIn2 = 0; /* 2nd input operand */
73457 Mem *pIn3 = 0; /* 3rd input operand */
73458 Mem *pOut = 0; /* Output operand */
74059 Mem *pVar; /* Value being transferred */
74177 Mem *pMem;
75240 Mem *pDest; /* Where to write the extracted value */
75241 Mem sMem; /* For storing the record being decoded */
75250 Mem *pReg; /* PseudoTable input register */
75536 Mem *pRec; /* The new record */
75543 Mem *pData0; /* First field to be combined into the record */
75544 Mem *pLast; /* Last field of the record */
76794 char aTempRec[ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*4 + 7];
76960 Mem *pMem; /* Register holding largest rowid for AUTOINCREMENT */
77034 assert( (pMem->flags & MEM_Int)!=0 ); /* mem(P3) holds an integer */
77121 Mem *pData; /* MEM cell holding data for the record to be inserted */
77122 Mem *pKey; /* MEM cell holding key for the record */
78207 Mem *pnErr; /* Register keeping track of errors remaining */
78364 Mem *pRt; /* Register to allocate runtime space */
78365 Mem *pMem; /* Used to iterate through memory cells */
78366 Mem *pEnd; /* Last memory cell in new array */
78410 + nMem * sizeof(Mem)
78488 Mem *pIn;
78713 Mem *pMem;
78714 Mem t;
78773 Mem *pMem;
78794 ** RESTART, or TRUNCATE. Write 1 or 0 into mem[P3] if the checkpoint returns
78796 ** WAL after the checkpoint into mem[P3+1] and the number of pages
78798 ** completes into mem[P3+2]. However on an error, mem[P3+1] and
78799 ** mem[P3+2] are initialized to -1.
78804 Mem *pMem; /* Write results here */
79048 Mem sMem; /* For storing the record being decoded */
79150 Mem *pQuery;
79151 Mem *pArgc;
79157 Mem **apArg;
79203 Mem *pDest;
79289 Mem *pName;
79345 Mem **apArg;
79346 Mem *pX;
81831 Mem *pVal /* Memory cell containing record */
82740 SQLITE_PRIVATE int sqlite3VdbeSorterRowkey(const VdbeCursor *pCsr, Mem *pOut){
82773 Mem *pVal, /* Value to compare to current sorter key */
100075 Mem *pArg = (Mem *)argv[0];
100076 Mem *pBest;
100079 pBest = (Mem *)sqlite3_aggregate_context(context, sizeof(*pBest));
111190 ** records the previous output. mem[regPrev] is a flag that is false
113772 int iAMem; /* First Mem address for storing current GROUP BY */
113773 int iBMem; /* First Mem address for previous GROUP BY */
113774 int iUseFlag; /* Mem address holding flag indicating that at least
113777 int iAbortFlag; /* Mem address which causes query abort if positive */
