Lines Matching defs:Mem
3632 typedef struct Mem sqlite3_value;
8453 typedef struct Mem Mem;
8478 Mem *pMem; /* Used when p4type is P4_MEM */
8531 #define P4_MEM (-8) /* P4 is a pointer to a Mem* structure */
8553 ** The Vdbe.aColName array contains 5n Mem structures, where n is the
10335 Mem *aMem; /* Values */
12947 Mem *aMem; /* Array of memory cells for parent frame */
12962 #define VdbeFrameMem(p) ((Mem *)&((u8 *)p)[ROUND8(sizeof(VdbeFrame))])
12970 ** Internally, the vdbe manipulates nearly all SQL values as Mem
12971 ** structures. Each Mem struct may cache multiple representations (string,
12974 struct Mem {
12990 Mem *pScopyFrom; /* This Mem is a shallow copy of pScopyFrom */
12991 void *pFiller; /* So that sizeof(Mem) is a multiple of 8 */
12993 void (*xDel)(void *); /* If not null, call this function to delete Mem.z */
12998 ** representations of the value stored in the Mem struct.
13003 ** If the MEM_Str flag is set then Mem.z points at a string representation.
13019 /* Whenever Mem contains a valid string or blob representation, one of
13021 ** policy for Mem.z. The MEM_Term flag tells us whether or not the
13025 #define MEM_Dyn 0x0400 /* Need to call sqliteFree() on Mem.z */
13026 #define MEM_Static 0x0800 /* Mem.z points to a static string */
13027 #define MEM_Ephem 0x1000 /* Mem.z points to an ephemeral string */
13028 #define MEM_Agg 0x2000 /* Mem.z points to an agg function context */
13029 #define MEM_Zero 0x4000 /* Mem.i contains count of 0s appended to blob */
13036 ** Clear any existing type flags from a Mem and replace them with f
13079 ** (Mem) which are only defined there.
13084 Mem s; /* The return value is stored here */
13085 Mem *pMem; /* Memory cell used to store aggregate context */
13121 Mem *aMem; /* The memory locations */
13122 Mem **apArg; /* Arguments to currently executing user function */
13123 Mem *aColName; /* Column names to return */
13124 Mem *pResultSet; /* Pointer to an array of results */
13136 Mem *aVar; /* Values for the OP_Variable opcode. */
13199 SQLITE_PRIVATE u32 sqlite3VdbeSerialType(Mem*, int);
13200 SQLITE_PRIVATE u32 sqlite3VdbeSerialPut(unsigned char*, int, Mem*, int);
13201 SQLITE_PRIVATE u32 sqlite3VdbeSerialGet(const unsigned char*, u32, Mem*);
13207 SQLITE_PRIVATE int sqlite3MemCompare(const Mem*, const Mem*, const CollSeq*);
13211 SQLITE_PRIVATE int sqlite3VdbeChangeEncoding(Mem *, int);
13212 SQLITE_PRIVATE int sqlite3VdbeMemTooBig(Mem*);
13213 SQLITE_PRIVATE int sqlite3VdbeMemCopy(Mem*, const Mem*);
13214 SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem*, const Mem*, int);
13215 SQLITE_PRIVATE void sqlite3VdbeMemMove(Mem*, Mem*);
13216 SQLITE_PRIVATE int sqlite3VdbeMemNulTerminate(Mem*);
13217 SQLITE_PRIVATE int sqlite3VdbeMemSetStr(Mem*, const char*, int, u8, void(*)(void*));
13218 SQLITE_PRIVATE void sqlite3VdbeMemSetInt64(Mem*, i64);
13222 SQLITE_PRIVATE void sqlite3VdbeMemSetDouble(Mem*, double);
13224 SQLITE_PRIVATE void sqlite3VdbeMemSetNull(Mem*);
13225 SQLITE_PRIVATE void sqlite3VdbeMemSetZeroBlob(Mem*,int);
13226 SQLITE_PRIVATE void sqlite3VdbeMemSetRowSet(Mem*);
13227 SQLITE_PRIVATE int sqlite3VdbeMemMakeWriteable(Mem*);
13228 SQLITE_PRIVATE int sqlite3VdbeMemStringify(Mem*, int);
13229 SQLITE_PRIVATE i64 sqlite3VdbeIntValue(Mem*);
13230 SQLITE_PRIVATE int sqlite3VdbeMemIntegerify(Mem*);
13231 SQLITE_PRIVATE double sqlite3VdbeRealValue(Mem*);
13232 SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem*);
13233 SQLITE_PRIVATE int sqlite3VdbeMemRealify(Mem*);
13234 SQLITE_PRIVATE int sqlite3VdbeMemNumerify(Mem*);
13235 SQLITE_PRIVATE int sqlite3VdbeMemFromBtree(BtCursor*,int,int,int,Mem*);
13236 SQLITE_PRIVATE void sqlite3VdbeMemRelease(Mem *p);
13237 SQLITE_PRIVATE void sqlite3VdbeMemReleaseExternal(Mem *p);
13241 SQLITE_PRIVATE int sqlite3VdbeMemFinalize(Mem*, FuncDef*);
13243 SQLITE_PRIVATE int sqlite3VdbeMemGrow(Mem *pMem, int n, int preserve);
13247 SQLITE_PRIVATE void sqlite3VdbeMemStoreType(Mem *pMem);
13261 SQLITE_PRIVATE int sqlite3VdbeSorterRowkey(VdbeCursor *, Mem *);
13264 SQLITE_PRIVATE int sqlite3VdbeSorterWrite(sqlite3 *, VdbeCursor *, Mem *);
13265 SQLITE_PRIVATE int sqlite3VdbeSorterCompare(VdbeCursor *, Mem *, int *);
13277 SQLITE_PRIVATE void sqlite3VdbeMemAboutToChange(Vdbe*,Mem*);
13286 SQLITE_PRIVATE int sqlite3VdbeMemTranslate(Mem*, u8);
13289 SQLITE_PRIVATE void sqlite3VdbeMemPrettyPrint(Mem *pMem, char *zBuf);
13291 SQLITE_PRIVATE int sqlite3VdbeMemHandleBom(Mem *pMem);
13294 SQLITE_PRIVATE int sqlite3VdbeMemExpandBlob(Mem *);
15535 ** into a single structure named "mem". This is to keep the
15580 } mem;
15592 mem.nAlloc[i]++;
15593 mem.nCurrent[i]++;
15594 if( mem.nCurrent[i]>mem.mxCurrent[i] ){
15595 mem.mxCurrent[i] = mem.nCurrent[i];
15598 mem.nCurrent[i]--;
15599 assert( mem.nCurrent[i]>=0 );
15651 mem.mutex = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM);
15661 mem.mutex = 0;
15707 sqlite3_mutex_enter(mem.mutex);
15708 assert( mem.disallow==0 );
15711 mem.nBacktrace*sizeof(void*) + mem.nTitle;
15715 pBt = (void**)&z[mem.nTitle];
15716 pHdr = (struct MemBlockHdr*)&pBt[mem.nBacktrace];
15718 pHdr->pPrev = mem.pLast;
15719 if( mem.pLast ){
15720 mem.pLast->pNext = pHdr;
15722 mem.pFirst = pHdr;
15724 mem.pLast = pHdr;
15727 pHdr->nBacktraceSlots = mem.nBacktrace;
15728 pHdr->nTitle = mem.nTitle;
15729 if( mem.nBacktrace ){
15731 pHdr->nBacktrace = backtrace(aAddr, mem.nBacktrace+1)-1;
15734 if( mem.xBacktrace ){
15735 mem.xBacktrace(nByte, pHdr->nBacktrace-1, &aAddr[1]);
15740 if( mem.nTitle ){
15741 memcpy(z, mem.zTitle, mem.nTitle);
15751 sqlite3_mutex_leave(mem.mutex);
15763 || mem.mutex!=0 );
15767 sqlite3_mutex_enter(mem.mutex);
15772 assert( mem.pFirst==pHdr );
15773 mem.pFirst = pHdr->pNext;
15779 assert( mem.pLast==pHdr );
15780 mem.pLast = pHdr->pPrev;
15788 sqlite3_mutex_leave(mem.mutex);
15803 assert( mem.disallow==0 );
15900 mem.nBacktrace = depth;
15904 mem.xBacktrace = xBacktrace;
15912 sqlite3_mutex_enter(mem.mutex);
15913 if( n>=sizeof(mem.zTitle) ) n = sizeof(mem.zTitle)-1;
15914 memcpy(mem.zTitle, zTitle, n);
15915 mem.zTitle[n] = 0;
15916 mem.nTitle = ROUND8(n);
15917 sqlite3_mutex_leave(mem.mutex);
15922 for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){
15925 mem.xBacktrace(pHdr->iSize, pHdr->nBacktrace-1, &pBt[1]);
15944 for(pHdr=mem.pFirst; pHdr; pHdr=pHdr->pNext){
15959 if( mem.nAlloc[i] ){
15961 i*8, mem.nAlloc[i], mem.nCurrent[i], mem.mxCurrent[i]);
15964 if( mem.nAlloc[NCSIZE-1] ){
15966 NCSIZE*8-8, mem.nAlloc[NCSIZE-1],
15967 mem.nCurrent[NCSIZE-1], mem.mxCurrent[NCSIZE-1]);
15979 nTotal += mem.nAlloc[i];
20676 ** If the TRANSLATE_TRACE macro is defined, the value of each Mem is
20687 SQLITE_PRIVATE int sqlite3VdbeMemTranslate(Mem *pMem, u8 desiredEnc){
20825 ** the encoding of the Mem adjusted. This routine does not do any
20826 ** byte-swapping, it just sets Mem.enc appropriately.
20828 ** The allocation (static, dynamic etc.) and encoding of the Mem may be
20831 SQLITE_PRIVATE int sqlite3VdbeMemHandleBom(Mem *pMem){
20924 Mem m;
20952 Mem m;
58369 ** This file contains code use to manipulate "Mem" structure. A "Mem"
58370 ** stores a single value in the VDBE. Mem is an opaque structure visible
58371 ** only within the VDBE. Interface routines refer to a Mem using the
58388 SQLITE_PRIVATE int sqlite3VdbeChangeEncoding(Mem *pMem, int desiredEnc){
58423 ** not set, Mem.n is zeroed.
58425 SQLITE_PRIVATE int sqlite3VdbeMemGrow(Mem *pMem, int n, int preserve){
58464 ** Make the given Mem object MEM_Dyn. In other words, make it so
58471 SQLITE_PRIVATE int sqlite3VdbeMemMakeWriteable(Mem *pMem){
58493 ** If the given Mem* has a zero-filled tail, turn it into an ordinary
58497 SQLITE_PRIVATE int sqlite3VdbeMemExpandBlob(Mem *pMem){
58523 ** Make sure the given Mem is \u0000 terminated.
58525 SQLITE_PRIVATE int sqlite3VdbeMemNulTerminate(Mem *pMem){
58540 ** Add MEM_Str to the set of representations for the given Mem. Numbers
58552 SQLITE_PRIVATE int sqlite3VdbeMemStringify(Mem *pMem, int enc){
58596 SQLITE_PRIVATE int sqlite3VdbeMemFinalize(Mem *pMem, FuncDef *pFunc){
58619 ** does not free any Mem.zMalloc buffer.
58621 SQLITE_PRIVATE void sqlite3VdbeMemReleaseExternal(Mem *p){
58640 ** Release any memory held by the Mem. This may leave the Mem in an
58641 ** inconsistent state, for example with (Mem.z==0) and
58642 ** (Mem.type==SQLITE_TEXT).
58644 SQLITE_PRIVATE void sqlite3VdbeMemRelease(Mem *p){
58704 SQLITE_PRIVATE i64 sqlite3VdbeIntValue(Mem *pMem){
58730 SQLITE_PRIVATE double sqlite3VdbeRealValue(Mem *pMem){
58749 ** The MEM structure is already a MEM_Real. Try to also make it a
58752 SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem *pMem){
58787 SQLITE_PRIVATE int sqlite3VdbeMemIntegerify(Mem *pMem){
58801 SQLITE_PRIVATE int sqlite3VdbeMemRealify(Mem *pMem){
58818 SQLITE_PRIVATE int sqlite3VdbeMemNumerify(Mem *pMem){
58838 SQLITE_PRIVATE void sqlite3VdbeMemSetNull(Mem *pMem){
58855 SQLITE_PRIVATE void sqlite3VdbeMemSetZeroBlob(Mem *pMem, int n){
58877 SQLITE_PRIVATE void sqlite3VdbeMemSetInt64(Mem *pMem, i64 val){
58889 SQLITE_PRIVATE void sqlite3VdbeMemSetDouble(Mem *pMem, double val){
58905 SQLITE_PRIVATE void sqlite3VdbeMemSetRowSet(Mem *pMem){
58923 ** Return true if the Mem object contains a TEXT or BLOB that is
58926 SQLITE_PRIVATE int sqlite3VdbeMemTooBig(Mem *p){
58947 SQLITE_PRIVATE void sqlite3VdbeMemAboutToChange(Vdbe *pVdbe, Mem *pMem){
58949 Mem *pX;
58961 ** Size of struct Mem not including the Mem.zMalloc member.
58963 #define MEMCELLSIZE (size_t)(&(((Mem *)0)->zMalloc))
58971 SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int srcType){
58987 SQLITE_PRIVATE int sqlite3VdbeMemCopy(Mem *pTo, const Mem *pFrom){
59011 SQLITE_PRIVATE void sqlite3VdbeMemMove(Mem *pTo, Mem *pFrom){
59017 memcpy(pTo, pFrom, sizeof(Mem));
59024 ** Change the value of a Mem to be a string or a BLOB.
59029 ** Mem structure. Otherwise, any existing buffer is freed and the
59039 Mem *pMem, /* Memory cell to set to string value */
59074 /* The following block sets the new values of Mem.z and Mem.xDel. It
59128 SQLITE_PRIVATE int sqlite3MemCompare(const Mem *pMem1, const Mem *pMem2, const CollSeq *pColl){
59209 Mem c1;
59210 Mem c2;
59238 ** Move data out of a btree key or data field and into a Mem structure.
59255 Mem *pMem /* OUT: Return data in this Mem structure. */
59347 Mem *p = sqlite3DbMallocZero(db, sizeof(*p));
59483 if( v ) sqlite3VdbeMemSetStr((Mem *)v, z, n, enc, xDel);
59491 sqlite3VdbeMemRelease((Mem *)v);
59492 sqlite3DbFree(((Mem*)v)->db, v);
59500 Mem *p = (Mem*)pVal;
60138 Mem *p = (Mem*)p4;
60423 Mem *pMem = pOp->p4.pMem;
60572 ** Release an array of N Mem elements
60574 static void releaseMemArray(Mem *p, int N){
60576 Mem *pEnd;
60619 Mem *aMem = VdbeFrameMem(p);
60650 Mem *pSub = 0; /* Memory cell hold array of subprogs */
60654 Mem *pMem = &p->aMem[1]; /* First Mem of result set */
61040 p->aMem = allocSpace(p->aMem, nMem*sizeof(Mem), &zCsr, zEnd, &nByte);
61041 p->aVar = allocSpace(p->aVar, nVar*sizeof(Mem), &zCsr, zEnd, &nByte);
61042 p->apArg = allocSpace(p->apArg, nArg*sizeof(Mem*), &zCsr, zEnd, &nByte);
61196 Mem *pColName;
61204 p->aColName = pColName = (Mem*)sqlite3DbMallocZero(db, sizeof(Mem)*n );
61231 Mem *pColName;
62083 SQLITE_PRIVATE u32 sqlite3VdbeSerialType(Mem *pMem, int file_format){
62207 SQLITE_PRIVATE u32 sqlite3VdbeSerialPut(u8 *buf, int nBuf, Mem *pMem, int file_format){
62260 Mem *pMem /* Memory cell to write value into */
62379 nByte = ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*(pKeyInfo->nField+1);
62389 p->aMem = (Mem
62411 Mem *pMem = p->aMem;
62463 Mem mem1;
62563 Mem m, v;
62645 Mem m;
62720 Mem *pMem = &v->aVar[iVar-1];
62724 sqlite3VdbeMemCopy((Mem *)pRet, pMem);
62726 sqlite3VdbeMemStoreType((Mem *)pRet);
62884 ** The following routines extract information from a Mem or sqlite3_value
62888 MemMem*)pVal;
62905 return sqlite3VdbeRealValue((Mem*)pVal);
62908 return (int)sqlite3VdbeIntValue((Mem*)pVal);
62911 return sqlite3VdbeIntValue((Mem*)pVal);
63316 Mem *pMem;
63434 ** it is, return a pointer to the Mem for the value of that column.
63435 ** If iCol is not valid, return a pointer to a Mem which has a value
63438 static Mem *columnMem(sqlite3_stmt *pStmt, int i){
63440 Mem *pOut;
63448 ** a pointer to the following static Mem object which contains the
63449 ** value SQL NULL. Even though the Mem structure contains an element
63451 ** switches (-Os), gcc may align this Mem object on a 4-byte boundary
63454 ** that a Mem structure is located on an 8-byte boundary. To prevent
63458 static const Mem nullMem
63472 pOut = (Mem*)&nullMem;
63554 Mem *pOut = columnMem(pStmt, i);
63601 const void *(*xFunc)(Mem*),
63634 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_NAME);
63639 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_NAME);
63659 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DECLTYPE);
63664 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DECLTYPE);
63677 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DATABASE);
63682 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DATABASE);
63693 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_TABLE);
63698 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_TABLE);
63709 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_COLUMN);
63714 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_COLUMN);
63736 Mem *pVar;
63788 Mem *pVar;
64139 Mem *pVar; /* Value of a host parameter */
64191 Mem utf8;
64437 static void updateMaxBlobsize(Mem *p){
64501 SQLITE_PRIVATE void sqlite3VdbeMemStoreType(Mem *pMem){
64548 Mem *pMem = &p->aMem[p->nMem-iCur];
64585 static void applyNumericAffinity(Mem *pRec){
64621 Mem *pRec, /* The value to apply affinity to */
64651 Mem *pMem = (Mem*)pVal;
64661 ** not the internal Mem* type.
64668 applyAffinity((Mem *)pVal, affinity, enc);
64676 SQLITE_PRIVATE void sqlite3VdbeMemPrettyPrint(Mem *pMem, char *zBuf){
64758 static void memTracePrint(FILE *out, Mem *p){
64778 static void registerTrace(FILE *out, int iReg, Mem *p){
64984 Mem *aMem = p->aMem; /* Copy of p->aMem */
64985 Mem *pIn1 = 0; /* 1st input operand */
64986 Mem *pIn2 = 0; /* 2nd input operand */
64987 Mem *pIn3 = 0; /* 3rd input operand */
64988 Mem *pOut = 0; /* Output operand */
65012 Mem *pVar; /* Value being transferred */
65021 Mem *pMem;
65036 Mem *pArg;
65084 Mem *pDest; /* Where to write the extracted value */
65085 Mem sMem; /* For storing the record being decoded */
65093 Mem *pReg; /* PseudoTable input register */
65101 Mem *pRec; /* The new record */
65108 Mem *pData0; /* First field to be combined into the record */
65109 Mem *pLast; /* Last field of the record */
65188 char aTempRec[ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*3 + 7];
65195 Mem *aMx;
65210 Mem *pMem; /* Register holding largest rowid for AUTOINCREMENT */
65214 Mem *pData; /* MEM cell holding data for the record to be inserted */
65215 Mem *pKey; /* MEM cell holding key for the record */
65312 Mem *pnErr; /* Register keeping track of errors remaining */
65324 Mem *pRt; /* Register to allocate runtime space */
65325 Mem *pMem; /* Used to iterate through memory cells */
65326 Mem *pEnd; /* Last memory cell in new array */
65333 Mem *pIn;
65336 Mem *pIn1;
65342 Mem *pMem;
65343 Mem *pRec;
65348 Mem *pMem;
65353 Mem *pMem; /* Write results here */
65378 Mem *pQuery;
65379 Mem *pArgc;
65385 Mem **apArg;
65390 Mem *pDest;
65401 Mem *pName;
65409 Mem **apArg;
65410 Mem *pX;
65505 ** external allocations out of mem[p2] and set mem[p2] to be
65507 ** value or convert mem[p2] to a different type.
65853 Mem *pVar; /* Value being transferred */
65962 Mem *pMem;
66235 Mem *pArg;
67017 Mem *pDest; /* Where to write the extracted value */
67018 Mem sMem; /* For storing the record being decoded */
67026 Mem *pReg; /* PseudoTable input register */
67247 ** a pointer to a Mem object.
67342 Mem *pRec; /* The new record */
67349 Mem *pData0; /* First field to be combined into the record */
67350 Mem *pLast; /* Last field of the record */
68475 char aTempRec[ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*3 + 7];
68561 Mem *aMx;
68708 Mem *pMem; /* Register holding largest rowid for AUTOINCREMENT */
68785 assert( (u.bg.pMem->flags & MEM_Int)!=0 ); /* mem(P3) holds an integer */
68886 Mem *pData; /* MEM cell holding data for the record to be inserted */
68887 Mem *pKey; /* MEM cell holding key for the record */
69878 Mem *pnErr; /* Register keeping track of errors remaining */
70037 Mem *pRt; /* Register to allocate runtime space */
70038 Mem *pMem; /* Used to iterate through memory cells */
70039 Mem *pEnd; /* Last memory cell in new array */
70084 + u.cc.nMem * sizeof(Mem)
70156 Mem *pIn;
70217 Mem *pIn1;
70301 Mem *pMem;
70302 Mem *pRec;
70366 Mem *pMem;
70388 ** or RESTART. Write 1 or 0 into mem[P3] if the checkpoint returns
70390 ** WAL after the checkpoint into mem[P3+1] and the number of pages
70392 ** completes into mem[P3+2]. However on an error, mem[P3+1] and
70393 ** mem[P3+2] are initialized to -1.
70399 Mem *pMem; /* Write results here */
70723 Mem *pQuery;
70724 Mem *pArgc;
70730 Mem **apArg;
70786 Mem *pDest;
70820 ** dynamic allocation in u.cn.sContext.s (a Mem struct) is released.
70891 Mem *pName;
70944 Mem **apArg;
70945 Mem *pX;
72255 Mem *pVal /* Memory cell containing record */
72487 SQLITE_PRIVATE int sqlite3VdbeSorterRowkey(VdbeCursor *pCsr, Mem *pOut){
72514 Mem *pVal, /* Value to compare to current sorter key */
79807 ** iMem+nCol+1 .. Mem+2*nCol:
87464 Mem *pArg = (Mem *)argv[0];
87465 Mem *pBest;
87468 pBest = (Mem *)sqlite3_aggregate_context(context, sizeof(*pBest));
92213 int mem = ++pParse->nMem;
92218 sqlite3VdbeAddOp4(v, OP_Int64, 0, mem, 0, (char*)pI64, P4_INT64);
92221 sqlite3VdbeAddOp2(v, OP_ResultRow, mem, 1);
92426 int mem = ++pParse->nMem;
92427 sqlite3VdbeAddOp4(v, OP_String8, 0, mem, 0, aFcntl[0], 0);
92430 sqlite3VdbeAddOp2(v, OP_ResultRow, mem, 1);
96426 ** records the previous output. mem[regPrev] is a flag that is false
98583 int iAMem; /* First Mem address for storing current GROUP BY */
98584 int iBMem; /* First Mem address for previous GROUP BY */
98585 int iUseFlag; /* Mem address holding flag indicating that at least
98588 int iAbortFlag; /* Mem address which causes query abort if positive */
