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;
58397 ** This file contains code use to manipulate "Mem" structure. A "Mem"
58398 ** stores a single value in the VDBE. Mem is an opaque structure visible
58399 ** only within the VDBE. Interface routines refer to a Mem using the
58416 SQLITE_PRIVATE int sqlite3VdbeChangeEncoding(Mem *pMem, int desiredEnc){
58451 ** not set, Mem.n is zeroed.
58453 SQLITE_PRIVATE int sqlite3VdbeMemGrow(Mem *pMem, int n, int preserve){
58492 ** Make the given Mem object MEM_Dyn. In other words, make it so
58499 SQLITE_PRIVATE int sqlite3VdbeMemMakeWriteable(Mem *pMem){
58521 ** If the given Mem* has a zero-filled tail, turn it into an ordinary
58525 SQLITE_PRIVATE int sqlite3VdbeMemExpandBlob(Mem *pMem){
58551 ** Make sure the given Mem is \u0000 terminated.
58553 SQLITE_PRIVATE int sqlite3VdbeMemNulTerminate(Mem *pMem){
58568 ** Add MEM_Str to the set of representations for the given Mem. Numbers
58580 SQLITE_PRIVATE int sqlite3VdbeMemStringify(Mem *pMem, int enc){
58624 SQLITE_PRIVATE int sqlite3VdbeMemFinalize(Mem *pMem, FuncDef *pFunc){
58647 ** does not free any Mem.zMalloc buffer.
58649 SQLITE_PRIVATE void sqlite3VdbeMemReleaseExternal(Mem *p){
58668 ** Release any memory held by the Mem. This may leave the Mem in an
58669 ** inconsistent state, for example with (Mem.z==0) and
58670 ** (Mem.type==SQLITE_TEXT).
58672 SQLITE_PRIVATE void sqlite3VdbeMemRelease(Mem *p){
58732 SQLITE_PRIVATE i64 sqlite3VdbeIntValue(Mem *pMem){
58758 SQLITE_PRIVATE double sqlite3VdbeRealValue(Mem *pMem){
58777 ** The MEM structure is already a MEM_Real. Try to also make it a
58780 SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem *pMem){
58815 SQLITE_PRIVATE int sqlite3VdbeMemIntegerify(Mem *pMem){
58829 SQLITE_PRIVATE int sqlite3VdbeMemRealify(Mem *pMem){
58846 SQLITE_PRIVATE int sqlite3VdbeMemNumerify(Mem *pMem){
58866 SQLITE_PRIVATE void sqlite3VdbeMemSetNull(Mem *pMem){
58883 SQLITE_PRIVATE void sqlite3VdbeMemSetZeroBlob(Mem *pMem, int n){
58905 SQLITE_PRIVATE void sqlite3VdbeMemSetInt64(Mem *pMem, i64 val){
58917 SQLITE_PRIVATE void sqlite3VdbeMemSetDouble(Mem *pMem, double val){
58933 SQLITE_PRIVATE void sqlite3VdbeMemSetRowSet(Mem *pMem){
58951 ** Return true if the Mem object contains a TEXT or BLOB that is
58954 SQLITE_PRIVATE int sqlite3VdbeMemTooBig(Mem *p){
58975 SQLITE_PRIVATE void sqlite3VdbeMemAboutToChange(Vdbe *pVdbe, Mem *pMem){
58977 Mem *pX;
58989 ** Size of struct Mem not including the Mem.zMalloc member.
58991 #define MEMCELLSIZE (size_t)(&(((Mem *)0)->zMalloc))
58999 SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int srcType){
59015 SQLITE_PRIVATE int sqlite3VdbeMemCopy(Mem *pTo, const Mem *pFrom){
59039 SQLITE_PRIVATE void sqlite3VdbeMemMove(Mem *pTo, Mem *pFrom){
59045 memcpy(pTo, pFrom, sizeof(Mem));
59052 ** Change the value of a Mem to be a string or a BLOB.
59057 ** Mem structure. Otherwise, any existing buffer is freed and the
59067 Mem *pMem, /* Memory cell to set to string value */
59102 /* The following block sets the new values of Mem.z and Mem.xDel. It
59156 SQLITE_PRIVATE int sqlite3MemCompare(const Mem *pMem1, const Mem *pMem2, const CollSeq *pColl){
59237 Mem c1;
59238 Mem c2;
59266 ** Move data out of a btree key or data field and into a Mem structure.
59283 Mem *pMem /* OUT: Return data in this Mem structure. */
59375 Mem *p = sqlite3DbMallocZero(db, sizeof(*p));
59511 if( v ) sqlite3VdbeMemSetStr((Mem *)v, z, n, enc, xDel);
59519 sqlite3VdbeMemRelease((Mem *)v);
59520 sqlite3DbFree(((Mem*)v)->db, v);
59528 Mem *p = (Mem*)pVal;
60166 Mem *p = (Mem*)p4;
60451 Mem *pMem = pOp->p4.pMem;
60600 ** Release an array of N Mem elements
60602 static void releaseMemArray(Mem *p, int N){
60604 Mem *pEnd;
60647 Mem *aMem = VdbeFrameMem(p);
60678 Mem *pSub = 0; /* Memory cell hold array of subprogs */
60682 Mem *pMem = &p->aMem[1]; /* First Mem of result set */
61068 p->aMem = allocSpace(p->aMem, nMem*sizeof(Mem), &zCsr, zEnd, &nByte);
61069 p->aVar = allocSpace(p->aVar, nVar*sizeof(Mem), &zCsr, zEnd, &nByte);
61070 p->apArg = allocSpace(p->apArg, nArg*sizeof(Mem*), &zCsr, zEnd, &nByte);
61224 Mem *pColName;
61232 p->aColName = pColName = (Mem*)sqlite3DbMallocZero(db, sizeof(Mem)*n );
61259 Mem *pColName;
62111 SQLITE_PRIVATE u32 sqlite3VdbeSerialType(Mem *pMem, int file_format){
62235 SQLITE_PRIVATE u32 sqlite3VdbeSerialPut(u8 *buf, int nBuf, Mem *pMem, int file_format){
62288 Mem *pMem /* Memory cell to write value into */
62407 nByte = ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*(pKeyInfo->nField+1);
62417 p->aMem = (Mem*)&((char*)p)[ROUND8(sizeof(UnpackedRecord))];
62439 Mem *pMem = p->aMem;
62491 Mem mem1;
62591 Mem m, v;
62673 Mem m;
62748 Mem *pMem = &v->aVar[iVar-1];
62752 sqlite3VdbeMemCopy((Mem *)pRet, pMem);
62754 sqlite3VdbeMemStoreType((Mem *)pRet);
62912 ** The following routines extract information from a Mem or sqlite3_value
62916 Mem *p = (Mem*)pVal;
62933 return sqlite3VdbeRealValue((Mem*)pVal);
62936 return (int)sqlite3VdbeIntValue((Mem*)pVal);
62939 return sqlite3VdbeIntValue((Mem*)pVal);
63344 Mem *pMem;
63462 ** it is, return a pointer to the Mem for the value of that column.
63463 ** If iCol is not valid, return a pointer to a Mem which has a value
63466 static Mem *columnMem(sqlite3_stmt *pStmt, int i){
63468 Mem *pOut;
63476 ** a pointer to the following static Mem object which contains the
63477 ** value SQL NULL. Even though the Mem structure contains an element
63479 ** switches (-Os), gcc may align this Mem object on a 4-byte boundary
63482 ** that a Mem structure is located on an 8-byte boundary. To prevent
63486 static const Mem nullMem
63500 pOut = (Mem*)&nullMem;
63582 Mem *pOut = columnMem(pStmt, i);
63629 const void *(*xFunc)(Mem*),
63662 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_NAME);
63667 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_NAME);
63687 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DECLTYPE);
63692 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DECLTYPE);
63705 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DATABASE);
63710 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DATABASE);
63721 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_TABLE);
63726 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_TABLE);
63737 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_COLUMN);
63742 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_COLUMN);
63764 Mem *pVar;
63816 Mem *pVar;
64167 Mem *pVar; /* Value of a host parameter */
64219 Mem utf8;
64465 static void updateMaxBlobsize(Mem *p){
64529 SQLITE_PRIVATE void sqlite3VdbeMemStoreType(Mem *pMem){
64576 Mem *pMem = &p->aMem[p->nMem-iCur];
64613 static void applyNumericAffinity(Mem *pRec){
64649 Mem *pRec, /* The value to apply affinity to */
64679 Mem *pMem = (Mem*)pVal;
64689 ** not the internal Mem* type.
64696 applyAffinity((Mem *)pVal, affinity, enc);
64704 SQLITE_PRIVATE void sqlite3VdbeMemPrettyPrint(Mem *pMem, char *zBuf){
64786 static void memTracePrint(FILE *out, Mem *p){
64806 static void registerTrace(FILE *out, int iReg, Mem *p){
65012 Mem *aMem = p->aMem; /* Copy of p->aMem */
65013 Mem *pIn1 = 0; /* 1st input operand */
65014 Mem *pIn2 = 0; /* 2nd input operand */
65015 Mem *pIn3 = 0; /* 3rd input operand */
65016 Mem *pOut = 0; /* Output operand */
65040 Mem *pVar; /* Value being transferred */
65049 Mem *pMem;
65064 Mem *pArg;
65112 Mem *pDest; /* Where to write the extracted value */
65113 Mem sMem; /* For storing the record being decoded */
65121 Mem *pReg; /* PseudoTable input register */
65129 Mem *pRec; /* The new record */
65136 Mem *pData0; /* First field to be combined into the record */
65137 Mem *pLast; /* Last field of the record */
65216 char aTempRec[ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*3 + 7];
65223 Mem *aMx;
65238 Mem *pMem; /* Register holding largest rowid for AUTOINCREMENT */
65242 Mem *pData; /* MEM cell holding data for the record to be inserted */
65243 Mem *pKey; /* MEM cell holding key for the record */
65340 Mem *pnErr; /* Register keeping track of errors remaining */
65352 Mem *pRt; /* Register to allocate runtime space */
65353 Mem *pMem; /* Used to iterate through memory cells */
65354 Mem *pEnd; /* Last memory cell in new array */
65361 Mem *pIn;
65364 Mem *pIn1;
65370 Mem *pMem;
65371 Mem *pRec;
65376 Mem *pMem;
65381 Mem *pMem; /* Write results here */
65406 Mem *pQuery;
65407 Mem *pArgc;
65413 Mem **apArg;
65418 Mem *pDest;
65429 Mem *pName;
65437 Mem **apArg;
65438 Mem *pX;
65533 ** external allocations out of mem[p2] and set mem[p2] to be
65535 ** value or convert mem[p2] to a different type.
65881 Mem *pVar; /* Value being transferred */
65990 Mem *pMem;
66263 Mem *pArg;
67045 Mem *pDest; /* Where to write the extracted value */
67046 Mem sMem; /* For storing the record being decoded */
67054 Mem *pReg; /* PseudoTable input register */
67275 ** a pointer to a Mem object.
67370 Mem *pRec; /* The new record */
67377 Mem *pData0; /* First field to be combined into the record */
67378 Mem *pLast; /* Last field of the record */
68503 char aTempRec[ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*3 + 7];
68589 Mem *aMx;
68736 Mem *pMem; /* Register holding largest rowid for AUTOINCREMENT */
68813 assert( (u.bg.pMem->flags & MEM_Int)!=0 ); /* mem(P3) holds an integer */
68914 Mem *pData; /* MEM cell holding data for the record to be inserted */
68915 Mem *pKey; /* MEM cell holding key for the record */
69906 Mem *pnErr; /* Register keeping track of errors remaining */
70065 Mem *pRt; /* Register to allocate runtime space */
70066 Mem *pMem; /* Used to iterate through memory cells */
70067 Mem *pEnd; /* Last memory cell in new array */
70112 + u.cc.nMem * sizeof(Mem)
70184 Mem *pIn;
70245 Mem *pIn1;
70329 Mem *pMem;
70330 Mem *pRec;
70394 Mem *pMem;
70416 ** or RESTART. Write 1 or 0 into mem[P3] if the checkpoint returns
70418 ** WAL after the checkpoint into mem[P3+1] and the number of pages
70420 ** completes into mem[P3+2]. However on an error, mem[P3+1] and
70421 ** mem[P3+2] are initialized to -1.
70427 Mem *pMem; /* Write results here */
70751 Mem *pQuery;
70752 Mem *pArgc;
70758 Mem **apArg;
70814 Mem *pDest;
70848 ** dynamic allocation in u.cn.sContext.s (a Mem struct) is released.
70919 Mem *pName;
70972 Mem **apArg;
70973 Mem *pX;
72283 Mem *pVal /* Memory cell containing record */
72515 SQLITE_PRIVATE int sqlite3VdbeSorterRowkey(VdbeCursor *pCsr, Mem *pOut){
72542 Mem *pVal, /* Value to compare to current sorter key */
79843 ** iMem+nCol+1 .. Mem+2*nCol:
87500 Mem *pArg = (Mem *)argv[0];
87501 Mem *pBest;
87504 pBest = (Mem *)sqlite3_aggregate_context(context, sizeof(*pBest));
92249 int mem = ++pParse->nMem;
92254 sqlite3VdbeAddOp4(v, OP_Int64, 0, mem, 0, (char*)pI64, P4_INT64);
92257 sqlite3VdbeAddOp2(v, OP_ResultRow, mem, 1);
92462 int mem = ++pParse->nMem;
92463 sqlite3VdbeAddOp4(v, OP_String8, 0, mem, 0, aFcntl[0], 0);
92466 sqlite3VdbeAddOp2(v, OP_ResultRow, mem, 1);
96462 ** records the previous output. mem[regPrev] is a flag that is false
98619 int iAMem; /* First Mem address for storing current GROUP BY */
98620 int iBMem; /* First Mem address for previous GROUP BY */
98621 Mem address holding flag indicating that at least
98624 int iAbortFlag; /* Mem address which causes query abort if positive */
