Lines Matching refs:pMem
16502 Mem *pMem; /* Used when p4type is P4_MEM */ member
23491 Mem *pMem; /* Memory cell used to store aggregate context */ member
23758 SQLITE_PRIVATE int sqlite3VdbeMemGrow(Mem *pMem, int n, int preserve);
23759 SQLITE_PRIVATE int sqlite3VdbeMemClearAndResize(Mem *pMem, int n);
23817 SQLITE_PRIVATE void sqlite3VdbeMemPrettyPrint(Mem *pMem, StrAccum *pStr);
23821 SQLITE_PRIVATE int sqlite3VdbeMemHandleBom(Mem *pMem);
34553 SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3VdbeMemTranslate(Mem *pMem, u8 desiredEnc){ in sqlite3VdbeMemTranslate() argument
34561 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) ); in sqlite3VdbeMemTranslate()
34562 assert( pMem->flags&MEM_Str ); in sqlite3VdbeMemTranslate()
34563 assert( pMem->enc!=desiredEnc ); in sqlite3VdbeMemTranslate()
34564 assert( pMem->enc!=0 ); in sqlite3VdbeMemTranslate()
34565 assert( pMem->n>=0 ); in sqlite3VdbeMemTranslate()
34572 sqlite3VdbeMemPrettyPrint(pMem, &acc); in sqlite3VdbeMemTranslate()
34581 if( pMem->enc!=SQLITE_UTF8 && desiredEnc!=SQLITE_UTF8 ){ in sqlite3VdbeMemTranslate()
34584 rc = sqlite3VdbeMemMakeWriteable(pMem); in sqlite3VdbeMemTranslate()
34589 zIn = (u8*)pMem->z; in sqlite3VdbeMemTranslate()
34590 zTerm = &zIn[pMem->n&~1]; in sqlite3VdbeMemTranslate()
34597 pMem->enc = desiredEnc; in sqlite3VdbeMemTranslate()
34608 pMem->n &= ~1; in sqlite3VdbeMemTranslate()
34609 len = 2 * (sqlite3_int64)pMem->n + 1; in sqlite3VdbeMemTranslate()
34616 len = 2 * (sqlite3_int64)pMem->n + 2; in sqlite3VdbeMemTranslate()
34625 zIn = (u8*)pMem->z; in sqlite3VdbeMemTranslate()
34626 zTerm = &zIn[pMem->n]; in sqlite3VdbeMemTranslate()
34627 zOut = sqlite3DbMallocRaw(pMem->db, len); in sqlite3VdbeMemTranslate()
34633 if( pMem->enc==SQLITE_UTF8 ){ in sqlite3VdbeMemTranslate()
34648 pMem->n = (int)(z - zOut); in sqlite3VdbeMemTranslate()
34652 if( pMem->enc==SQLITE_UTF16LE ){ in sqlite3VdbeMemTranslate()
34711 pMem->n = (int)(z - zOut); in sqlite3VdbeMemTranslate()
34714 assert( (pMem->n+(desiredEnc==SQLITE_UTF8?1:2))<=len ); in sqlite3VdbeMemTranslate()
34716 c = MEM_Str|MEM_Term|(pMem->flags&(MEM_AffMask|MEM_Subtype)); in sqlite3VdbeMemTranslate()
34717 sqlite3VdbeMemRelease(pMem); in sqlite3VdbeMemTranslate()
34718 pMem->flags = c; in sqlite3VdbeMemTranslate()
34719 pMem->enc = desiredEnc; in sqlite3VdbeMemTranslate()
34720 pMem->z = (char*)zOut; in sqlite3VdbeMemTranslate()
34721 pMem->zMalloc = pMem->z; in sqlite3VdbeMemTranslate()
34722 pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->z); in sqlite3VdbeMemTranslate()
34730 sqlite3VdbeMemPrettyPrint(pMem, &acc); in sqlite3VdbeMemTranslate()
34748 SQLITE_PRIVATE int sqlite3VdbeMemHandleBom(Mem *pMem){ in sqlite3VdbeMemHandleBom() argument
34752 assert( pMem->n>=0 ); in sqlite3VdbeMemHandleBom()
34753 if( pMem->n>1 ){ in sqlite3VdbeMemHandleBom()
34754 u8 b1 = *(u8 *)pMem->z; in sqlite3VdbeMemHandleBom()
34755 u8 b2 = *(((u8 *)pMem->z) + 1); in sqlite3VdbeMemHandleBom()
34765 rc = sqlite3VdbeMemMakeWriteable(pMem); in sqlite3VdbeMemHandleBom()
34767 pMem->n -= 2; in sqlite3VdbeMemHandleBom()
34768 memmove(pMem->z, &pMem->z[2], pMem->n); in sqlite3VdbeMemHandleBom()
34769 pMem->z[pMem->n] = '\0'; in sqlite3VdbeMemHandleBom()
34770 pMem->z[pMem->n+1] = '\0'; in sqlite3VdbeMemHandleBom()
34771 pMem->flags |= MEM_Term; in sqlite3VdbeMemHandleBom()
34772 pMem->enc = bom; in sqlite3VdbeMemHandleBom()
43287 void *pMem;
43289 pMem = osMmap(0, nMap,
43293 if( pMem==MAP_FAILED ){
43298 pMem = sqlite3_malloc64(nMap);
43299 if( pMem==0 ){
43303 memset(pMem, 0, nMap);
43307 pShmNode->apRegion[pShmNode->nRegion+i] = &((char*)pMem)[szRegion*i];
47945 MUTEX_LOGIC( sqlite3_mutex *pMem; ) /* The memsys static mutex */
47947 MUTEX_LOGIC( pMem = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MEM); )
47949 sqlite3_mutex_enter(pMem);
47976 sqlite3_mutex_leave(pMem);
82985 SQLITE_PRIVATE int sqlite3VdbeChangeEncoding(Mem *pMem, int desiredEnc){
82989 assert( pMem!=0 );
82990 assert( !sqlite3VdbeMemIsRowSet(pMem) );
82993 if( !(pMem->flags&MEM_Str) ){
82994 pMem->enc = desiredEnc;
82997 if( pMem->enc==desiredEnc ){
83000 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
83008 rc = sqlite3VdbeMemTranslate(pMem, (u8)desiredEnc);
83010 assert(rc==SQLITE_OK || pMem->enc!=desiredEnc);
83011 assert(rc==SQLITE_NOMEM || pMem->enc==desiredEnc);
83024 SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3VdbeMemGrow(Mem *pMem, int n, int bPreserve){
83025 assert( sqlite3VdbeCheckMemInvariants(pMem) );
83026 assert( !sqlite3VdbeMemIsRowSet(pMem) );
83027 testcase( pMem->db==0 );
83031 assert( bPreserve==0 || pMem->flags&(MEM_Blob|MEM_Str) );
83032 testcase( bPreserve && pMem->z==0 );
83034 assert( pMem->szMalloc==0
83035 || (pMem->flags==MEM_Undefined
83036 && pMem->szMalloc<=sqlite3DbMallocSize(pMem->db,pMem->zMalloc))
83037 || pMem->szMalloc==sqlite3DbMallocSize(pMem->db,pMem->zMalloc));
83038 if( pMem->szMalloc>0 && bPreserve && pMem->z==pMem->zMalloc ){
83039 if( pMem->db ){
83040 pMem->z = pMem->zMalloc = sqlite3DbReallocOrFree(pMem->db, pMem->z, n);
83042 pMem->zMalloc = sqlite3Realloc(pMem->z, n);
83043 if( pMem->zMalloc==0 ) sqlite3_free(pMem->z);
83044 pMem->z = pMem->zMalloc;
83048 if( pMem->szMalloc>0 ) sqlite3DbFreeNN(pMem->db, pMem->zMalloc);
83049 pMem->zMalloc = sqlite3DbMallocRaw(pMem->db, n);
83051 if( pMem->zMalloc==0 ){
83052 sqlite3VdbeMemSetNull(pMem);
83053 pMem->z = 0;
83054 pMem->szMalloc = 0;
83057 pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->zMalloc);
83060 if( bPreserve && pMem->z ){
83061 assert( pMem->z!=pMem->zMalloc );
83062 memcpy(pMem->zMalloc, pMem->z, pMem->n);
83064 if( (pMem->flags&MEM_Dyn)!=0 ){
83065 assert( pMem->xDel!=0 && pMem->xDel!=SQLITE_DYNAMIC );
83066 pMem->xDel((void *)(pMem->z));
83069 pMem->z = pMem->zMalloc;
83070 pMem->flags &= ~(MEM_Dyn|MEM_Ephem|MEM_Static);
83087 SQLITE_PRIVATE int sqlite3VdbeMemClearAndResize(Mem *pMem, int szNew){
83089 assert( (pMem->flags & MEM_Dyn)==0 || pMem->szMalloc==0 );
83090 if( pMem->szMalloc<szNew ){
83091 return sqlite3VdbeMemGrow(pMem, szNew, 0);
83093 assert( (pMem->flags & MEM_Dyn)==0 );
83094 pMem->z = pMem->zMalloc;
83095 pMem->flags &= (MEM_Null|MEM_Int|MEM_Real|MEM_IntReal);
83106 SQLITE_PRIVATE void sqlite3VdbeMemZeroTerminateIfAble(Mem *pMem){
83107 if( (pMem->flags & (MEM_Str|MEM_Term|MEM_Ephem|MEM_Static))!=MEM_Str ){
83111 if( pMem->enc!=SQLITE_UTF8 ) return;
83112 if( NEVER(pMem->z==0) ) return;
83113 if( pMem->flags & MEM_Dyn ){
83114 if( pMem->xDel==sqlite3_free
83115 && sqlite3_msize(pMem->z) >= (u64)(pMem->n+1)
83117 pMem->z[pMem->n] = 0;
83118 pMem->flags |= MEM_Term;
83121 if( pMem->xDel==sqlite3RCStrUnref ){
83123 pMem->flags |= MEM_Term;
83126 }else if( pMem->szMalloc >= pMem->n+1 ){
83127 pMem->z[pMem->n] = 0;
83128 pMem->flags |= MEM_Term;
83142 static SQLITE_NOINLINE int vdbeMemAddTerminator(Mem *pMem){
83143 if( sqlite3VdbeMemGrow(pMem, pMem->n+3, 1) ){
83146 pMem->z[pMem->n] = 0;
83147 pMem->z[pMem->n+1] = 0;
83148 pMem->z[pMem->n+2] = 0;
83149 pMem->flags |= MEM_Term;
83159 SQLITE_PRIVATE int sqlite3VdbeMemMakeWriteable(Mem *pMem){
83160 assert( pMem!=0 );
83161 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
83162 assert( !sqlite3VdbeMemIsRowSet(pMem) );
83163 if( (pMem->flags & (MEM_Str|MEM_Blob))!=0 ){
83164 if( ExpandBlob(pMem) ) return SQLITE_NOMEM;
83165 if( pMem->szMalloc==0 || pMem->z!=pMem->zMalloc ){
83166 int rc = vdbeMemAddTerminator(pMem);
83170 pMem->flags &= ~MEM_Ephem;
83172 pMem->pScopyFrom = 0;
83183 SQLITE_PRIVATE int sqlite3VdbeMemExpandBlob(Mem *pMem){
83185 assert( pMem!=0 );
83186 assert( pMem->flags & MEM_Zero );
83187 assert( (pMem->flags&MEM_Blob)!=0 || MemNullNochng(pMem) );
83188 testcase( sqlite3_value_nochange(pMem) );
83189 assert( !sqlite3VdbeMemIsRowSet(pMem) );
83190 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
83193 nByte = pMem->n + pMem->u.nZero;
83195 if( (pMem->flags & MEM_Blob)==0 ) return SQLITE_OK;
83198 if( sqlite3VdbeMemGrow(pMem, nByte, 1) ){
83201 assert( pMem->z!=0 );
83202 assert( sqlite3DbMallocSize(pMem->db,pMem->z) >= nByte );
83204 memset(&pMem->z[pMem->n], 0, pMem->u.nZero);
83205 pMem->n += pMem->u.nZero;
83206 pMem->flags &= ~(MEM_Zero|MEM_Term);
83214 SQLITE_PRIVATE int sqlite3VdbeMemNulTerminate(Mem *pMem){
83215 assert( pMem!=0 );
83216 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
83217 testcase( (pMem->flags & (MEM_Term|MEM_Str))==(MEM_Term|MEM_Str) );
83218 testcase( (pMem->flags & (MEM_Term|MEM_Str))==0 );
83219 if( (pMem->flags & (MEM_Term|MEM_Str))!=MEM_Str ){
83222 return vdbeMemAddTerminator(pMem);
83240 SQLITE_PRIVATE int sqlite3VdbeMemStringify(Mem *pMem, u8 enc, u8 bForce){
83243 assert( pMem!=0 );
83244 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
83245 assert( !(pMem->flags&MEM_Zero) );
83246 assert( !(pMem->flags&(MEM_Str|MEM_Blob)) );
83247 assert( pMem->flags&(MEM_Int|MEM_Real|MEM_IntReal) );
83248 assert( !sqlite3VdbeMemIsRowSet(pMem) );
83249 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
83252 if( sqlite3VdbeMemClearAndResize(pMem, nByte) ){
83253 pMem->enc = 0;
83257 vdbeMemRenderNum(nByte, pMem->z, pMem);
83258 assert( pMem->z!=0 );
83259 assert( pMem->n==(int)sqlite3Strlen30NN(pMem->z) );
83260 pMem->enc = SQLITE_UTF8;
83261 pMem->flags |= MEM_Str|MEM_Term;
83262 if( bForce ) pMem->flags &= ~(MEM_Int|MEM_Real|MEM_IntReal);
83263 sqlite3VdbeChangeEncoding(pMem, enc);
83275 SQLITE_PRIVATE int sqlite3VdbeMemFinalize(Mem *pMem, FuncDef *pFunc){
83279 assert( pMem!=0 );
83280 assert( pMem->db!=0 );
83282 assert( (pMem->flags & MEM_Null)!=0 || pFunc==pMem->u.pDef );
83283 assert( sqlite3_mutex_held(pMem->db->mutex) );
83287 t.db = pMem->db;
83289 ctx.pMem = pMem;
83293 assert( (pMem->flags & MEM_Dyn)==0 );
83294 if( pMem->szMalloc>0 ) sqlite3DbFreeNN(pMem->db, pMem->zMalloc);
83295 memcpy(pMem, &t, sizeof(t));
83318 ctx.pMem = pAccum;
83405 static SQLITE_NOINLINE i64 memIntValue(const Mem *pMem){
83407 sqlite3Atoi64(pMem->z, &value, pMem->n, pMem->enc);
83410 SQLITE_PRIVATE i64 sqlite3VdbeIntValue(const Mem *pMem){
83412 assert( pMem!=0 );
83413 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
83414 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
83415 flags = pMem->flags;
83418 return pMem->u.i;
83420 return sqlite3RealToI64(pMem->u.r);
83421 }else if( (flags & (MEM_Str|MEM_Blob))!=0 && pMem->z!=0 ){
83422 return memIntValue(pMem);
83434 static SQLITE_NOINLINE double memRealValue(Mem *pMem){
83437 sqlite3AtoF(pMem->z, &val, pMem->n, pMem->enc);
83440 SQLITE_PRIVATE double sqlite3VdbeRealValue(Mem *pMem){
83441 assert( pMem!=0 );
83442 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
83443 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
83444 if( pMem->flags & MEM_Real ){
83445 return pMem->u.r;
83446 }else if( pMem->flags & (MEM_Int|MEM_IntReal) ){
83447 testcase( pMem->flags & MEM_IntReal );
83448 return (double)pMem->u.i;
83449 }else if( pMem->flags & (MEM_Str|MEM_Blob) ){
83450 return memRealValue(pMem);
83461 SQLITE_PRIVATE int sqlite3VdbeBooleanValue(Mem *pMem, int ifNull){
83462 testcase( pMem->flags & MEM_IntReal );
83463 if( pMem->flags & (MEM_Int|MEM_IntReal) ) return pMem->u.i!=0;
83464 if( pMem->flags & MEM_Null ) return ifNull;
83465 return sqlite3VdbeRealValue(pMem)!=0.0;
83472 SQLITE_PRIVATE void sqlite3VdbeIntegerAffinity(Mem *pMem){
83473 assert( pMem!=0 );
83474 assert( pMem->flags & (MEM_Real|MEM_IntReal) );
83475 assert( !sqlite3VdbeMemIsRowSet(pMem) );
83476 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
83477 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
83479 if( pMem->flags & MEM_IntReal ){
83480 MemSetTypeFlag(pMem, MEM_Int);
83482 i64 ix = sqlite3RealToI64(pMem->u.r);
83494 if( pMem->u.r==ix && ix>SMALLEST_INT64 && ix<LARGEST_INT64 ){
83495 pMem->u.i = ix;
83496 MemSetTypeFlag(pMem, MEM_Int);
83504 SQLITE_PRIVATE int sqlite3VdbeMemIntegerify(Mem *pMem){
83505 assert( pMem!=0 );
83506 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
83507 assert( !sqlite3VdbeMemIsRowSet(pMem) );
83508 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
83510 pMem->u.i = sqlite3VdbeIntValue(pMem);
83511 MemSetTypeFlag(pMem, MEM_Int);
83519 SQLITE_PRIVATE int sqlite3VdbeMemRealify(Mem *pMem){
83520 assert( pMem!=0 );
83521 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
83522 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
83524 pMem->u.r = sqlite3VdbeRealValue(pMem);
83525 MemSetTypeFlag(pMem, MEM_Real);
83563 SQLITE_PRIVATE int sqlite3VdbeMemNumerify(Mem *pMem){
83564 assert( pMem!=0 );
83565 testcase( pMem->flags & MEM_Int );
83566 testcase( pMem->flags & MEM_Real );
83567 testcase( pMem->flags & MEM_IntReal );
83568 testcase( pMem->flags & MEM_Null );
83569 if( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Null))==0 ){
83572 assert( (pMem->flags & (MEM_Blob|MEM_Str))!=0 );
83573 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
83574 rc = sqlite3AtoF(pMem->z, &pMem->u.r, pMem->n, pMem->enc);
83575 if( ((rc==0 || rc==1) && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)<=1)
83576 || sqlite3RealSameAsInt(pMem->u.r, (ix = sqlite3RealToI64(pMem->u.r)))
83578 pMem->u.i = ix;
83579 MemSetTypeFlag(pMem, MEM_Int);
83581 MemSetTypeFlag(pMem, MEM_Real);
83584 assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Null))!=0 );
83585 pMem->flags &= ~(MEM_Str|MEM_Blob|MEM_Zero);
83596 SQLITE_PRIVATE int sqlite3VdbeMemCast(Mem *pMem, u8 aff, u8 encoding){
83597 if( pMem->flags & MEM_Null ) return SQLITE_OK;
83600 if( (pMem->flags & MEM_Blob)==0 ){
83601 sqlite3ValueApplyAffinity(pMem, SQLITE_AFF_TEXT, encoding);
83602 assert( pMem->flags & MEM_Str || pMem->db->mallocFailed );
83603 if( pMem->flags & MEM_Str ) MemSetTypeFlag(pMem, MEM_Blob);
83605 pMem->flags &= ~(MEM_TypeMask&~MEM_Blob);
83610 sqlite3VdbeMemNumerify(pMem);
83614 sqlite3VdbeMemIntegerify(pMem);
83618 sqlite3VdbeMemRealify(pMem);
83625 pMem->flags |= (pMem->flags&MEM_Blob)>>3;
83626 sqlite3ValueApplyAffinity(pMem, SQLITE_AFF_TEXT, encoding);
83627 assert( pMem->flags & MEM_Str || pMem->db->mallocFailed );
83628 pMem->flags &= ~(MEM_Int|MEM_Real|MEM_IntReal|MEM_Blob|MEM_Zero);
83629 if( encoding!=SQLITE_UTF8 ) pMem->n &= ~1;
83630 rc = sqlite3VdbeChangeEncoding(pMem, encoding);
83632 sqlite3VdbeMemZeroTerminateIfAble(pMem);
83643 SQLITE_PRIVATE void sqlite3VdbeMemInit(Mem *pMem, sqlite3 *db, u16 flags){
83645 pMem->flags = flags;
83646 pMem->db = db;
83647 pMem->szMalloc = 0;
83663 SQLITE_PRIVATE void sqlite3VdbeMemSetNull(Mem *pMem){
83664 if( VdbeMemDynamic(pMem) ){
83665 vdbeMemClearExternAndSetNull(pMem);
83667 pMem->flags = MEM_Null;
83679 SQLITE_PRIVATE void sqlite3VdbeMemSetZeroBlob(Mem *pMem, int n){
83680 sqlite3VdbeMemRelease(pMem);
83681 pMem->flags = MEM_Blob|MEM_Zero;
83682 pMem->n = 0;
83684 pMem->u.nZero = n;
83685 pMem->enc = SQLITE_UTF8;
83686 pMem->z = 0;
83689 SQLITE_PRIVATE int sqlite3VdbeMemSetZeroBlob(Mem *pMem, int n){
83691 if( sqlite3VdbeMemGrow(pMem, nByte, 0) ){
83694 assert( pMem->z!=0 );
83695 assert( sqlite3DbMallocSize(pMem->db, pMem->z)>=nByte );
83696 memset(pMem->z, 0, nByte);
83697 pMem->n = n>0?n:0;
83698 pMem->flags = MEM_Blob;
83699 pMem->enc = SQLITE_UTF8;
83709 static SQLITE_NOINLINE void vdbeReleaseAndSetInt64(Mem *pMem, i64 val){
83710 sqlite3VdbeMemSetNull(pMem);
83711 pMem->u.i = val;
83712 pMem->flags = MEM_Int;
83719 SQLITE_PRIVATE void sqlite3VdbeMemSetInt64(Mem *pMem, i64 val){
83720 if( VdbeMemDynamic(pMem) ){
83721 vdbeReleaseAndSetInt64(pMem, val);
83723 pMem->u.i = val;
83724 pMem->flags = MEM_Int;
83743 Mem *pMem,
83748 assert( pMem->flags==MEM_Null );
83749 vdbeMemClear(pMem);
83750 pMem->u.zPType = zPType ? zPType : "";
83751 pMem->z = pPtr;
83752 pMem->flags = MEM_Null|MEM_Dyn|MEM_Subtype|MEM_Term;
83753 pMem->eSubtype = 'p';
83754 pMem->xDel = xDestructor ? xDestructor : sqlite3NoopDestructor;
83762 SQLITE_PRIVATE void sqlite3VdbeMemSetDouble(Mem *pMem, double val){
83763 sqlite3VdbeMemSetNull(pMem);
83765 pMem->u.r = val;
83766 pMem->flags = MEM_Real;
83776 SQLITE_PRIVATE int sqlite3VdbeMemIsRowSet(const Mem *pMem){
83777 return (pMem->flags&(MEM_Blob|MEM_Dyn))==(MEM_Blob|MEM_Dyn)
83778 && pMem->xDel==sqlite3RowSetDelete;
83789 SQLITE_PRIVATE int sqlite3VdbeMemSetRowSet(Mem *pMem){
83790 sqlite3 *db = pMem->db;
83793 assert( !sqlite3VdbeMemIsRowSet(pMem) );
83794 sqlite3VdbeMemRelease(pMem);
83797 pMem->z = (char*)p;
83798 pMem->flags = MEM_Blob|MEM_Dyn;
83799 pMem->xDel = sqlite3RowSetDelete;
83828 SQLITE_PRIVATE void sqlite3VdbeMemAboutToChange(Vdbe *pVdbe, Mem *pMem){
83832 if( pX->pScopyFrom==pMem ){
83836 (int)(pX - pVdbe->aMem), (int)(pMem - pVdbe->aMem));
83844 mFlags = pMem->flags & pX->flags & pX->mScopyFlags;
83845 assert( (mFlags&(MEM_Int|MEM_IntReal))==0 || pMem->u.i==pX->u.i );
83853 pMem->pScopyFrom = 0;
83941 Mem *pMem, /* Memory cell to set to string value */
83951 assert( pMem!=0 );
83952 assert( pMem->db==0 || sqlite3_mutex_held(pMem->db->mutex) );
83953 assert( !sqlite3VdbeMemIsRowSet(pMem) );
83958 sqlite3VdbeMemSetNull(pMem);
83962 if( pMem->db ){
83963 iLimit = pMem->db->aLimit[SQLITE_LIMIT_LENGTH];
83984 sqlite3DbFree(pMem->db, (void*)z);
83989 sqlite3VdbeMemSetNull(pMem);
83990 return sqlite3ErrorToParser(pMem->db, SQLITE_TOOBIG);
84005 if( sqlite3VdbeMemClearAndResize(pMem, (int)MAX(nAlloc,32)) ){
84008 memcpy(pMem->z, z, nAlloc);
84010 sqlite3VdbeMemRelease(pMem);
84011 pMem->z = (char *)z;
84013 pMem->zMalloc = pMem->z;
84014 pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->zMalloc);
84016 pMem->xDel = xDel;
84021 pMem->n = (int)(nByte & 0x7fffffff);
84022 pMem->flags = flags;
84023 pMem->enc = enc;
84026 if( enc>SQLITE_UTF8 && sqlite3VdbeMemHandleBom(pMem) ){
84054 Mem *pMem /* OUT: Return data in this Mem structure. */
84057 pMem->flags = MEM_Null;
84061 if( SQLITE_OK==(rc = sqlite3VdbeMemClearAndResize(pMem, amt+1)) ){
84062 rc = sqlite3BtreePayload(pCur, offset, amt, pMem->z);
84064 pMem->z[amt] = 0; /* Overrun area used when reading malformed records */
84065 pMem->flags = MEM_Blob;
84066 pMem->n = (int)amt;
84068 sqlite3VdbeMemRelease(pMem);
84076 Mem *pMem /* OUT: Return data in this Mem structure. */
84082 assert( !VdbeMemDynamic(pMem) );
84086 assert( !sqlite3VdbeMemIsRowSet(pMem) );
84087 pMem->z = (char *)sqlite3BtreePayloadFetch(pCur, &available);
84088 assert( pMem->z!=0 );
84091 pMem->flags = MEM_Blob|MEM_Ephem;
84092 pMem->n = (int)amt;
84094 rc = sqlite3VdbeMemFromBtree(pCur, 0, amt, pMem);
84740 Mem *pMem = *ppVal; /* Write result into this Mem object */
84757 if( pMem==0 ){
84758 pMem = *ppVal = sqlite3ValueNew(db);
84759 if( pMem==0 ) return SQLITE_NOMEM_BKPT;
84761 sqlite3VdbeSerialGet(&a[iField-szField], t, pMem);
84762 pMem->enc = ENC(db);
86791 Mem *pMem = pOp->p4.pMem;
86792 if( pMem->flags & MEM_Str ){
86793 zP4 = pMem->z;
86794 }else if( pMem->flags & (MEM_Int|MEM_IntReal) ){
86795 sqlite3_str_appendf(&x, "%lld", pMem->u.i);
86796 }else if( pMem->flags & MEM_Real ){
86797 sqlite3_str_appendf(&x, "%.16g", pMem->u.r);
86798 }else if( pMem->flags & MEM_Null ){
86801 assert( pMem->flags & MEM_Blob );
87227 Mem *pMem = &p->aMem[1]; /* First Mem of result set */
87240 releaseMemArray(pMem, 8);
87272 sqlite3VdbeMemSetInt64(pMem, pOp->p1);
87273 sqlite3VdbeMemSetInt64(pMem+1, pOp->p2);
87274 sqlite3VdbeMemSetInt64(pMem+2, pOp->p3);
87275 sqlite3VdbeMemSetStr(pMem+3, zP4, -1, SQLITE_UTF8, sqlite3_free);
87278 sqlite3VdbeMemSetInt64(pMem+0, i);
87279 sqlite3VdbeMemSetStr(pMem+1, (char*)sqlite3OpcodeName(pOp->opcode),
87281 sqlite3VdbeMemSetInt64(pMem+2, pOp->p1);
87282 sqlite3VdbeMemSetInt64(pMem+3, pOp->p2);
87283 sqlite3VdbeMemSetInt64(pMem+4, pOp->p3);
87285 sqlite3VdbeMemSetInt64(pMem+6, pOp->p5);
87289 sqlite3VdbeMemSetStr(pMem+7, zCom, -1, SQLITE_UTF8, sqlite3_free);
87292 sqlite3VdbeMemSetNull(pMem+7);
87294 sqlite3VdbeMemSetStr(pMem+5, zP4, -1, SQLITE_UTF8, sqlite3_free);
87297 p->pResultRow = pMem;
88707 SQLITE_PRIVATE u32 sqlite3VdbeSerialType(Mem *pMem, int file_format, u32 *pLen){
88708 int flags = pMem->flags;
88719 i64 i = pMem->u.i;
88746 pMem->u.r = (double)pMem->u.i;
88747 pMem->flags &= ~MEM_IntReal;
88748 pMem->flags |= MEM_Real;
88757 assert( pMem->db->mallocFailed || flags&(MEM_Str|MEM_Blob) );
88758 assert( pMem->n>=0 );
88759 n = (u32)pMem->n;
88761 n += pMem->u.nZero;
88877 Mem *pMem /* Memory cell to write value into */
88885 pMem->u.i = *(i64*)&x;
88886 pMem->flags = MEM_Int;
88887 testcase( pMem->u.i<0 );
88903 assert( sizeof(x)==8 && sizeof(pMem->u.r)==8 );
88905 memcpy(&pMem->u.r, &x, sizeof(x));
88906 pMem->flags = IsNaN(x) ? MEM_Null : MEM_Real;
88911 Mem *pMem /* Memory cell to write value into */
88916 assert( sizeof(x)==8 && sizeof(pMem->u.r)==8 );
88918 memcpy(&pMem->u.r, &x, sizeof(x));
88920 pMem->flags = MEM_Null;
88923 pMem->flags = MEM_Real;
88929 Mem *pMem /* Memory cell to write value into */
88934 pMem->flags = MEM_Null|MEM_Zero;
88935 pMem->n = 0;
88936 pMem->u.nZero = 0;
88942 pMem->flags = MEM_Null;
88948 pMem->u.i = ONE_BYTE_INT(buf);
88949 pMem->flags = MEM_Int;
88950 testcase( pMem->u.i<0 );
88956 pMem->u.i = TWO_BYTE_INT(buf);
88957 pMem->flags = MEM_Int;
88958 testcase( pMem->u.i<0 );
88964 pMem->u.i = THREE_BYTE_INT(buf);
88965 pMem->flags = MEM_Int;
88966 testcase( pMem->u.i<0 );
88972 pMem->u.i = FOUR_BYTE_INT(buf);
88975 if( buf[0]&0x80 ) pMem->u.i |= 0xffffffff80000000LL;
88977 pMem->flags = MEM_Int;
88978 testcase( pMem->u.i<0 );
88984 pMem->u.i = FOUR_BYTE_UINT(buf+2) + (((i64)1)<<32)*TWO_BYTE_INT(buf);
88985 pMem->flags = MEM_Int;
88986 testcase( pMem->u.i<0 );
88993 serialGet(buf,serial_type,pMem);
89000 pMem->u.i = serial_type-8;
89001 pMem->flags = MEM_Int;
89010 pMem->z = (char *)buf;
89011 pMem->n = (serial_type-12)/2;
89012 pMem->flags = aFlag[serial_type&1];
89063 Mem *pMem = p->aMem;
89066 assert( EIGHT_BYTE_ALIGNMENT(pMem) );
89074 pMem->enc = pKeyInfo->enc;
89075 pMem->db = pKeyInfo->db;
89077 pMem->szMalloc = 0;
89078 pMem->z = 0;
89079 sqlite3VdbeSerialGet(&aKey[d], serial_type, pMem);
89081 pMem++;
89089 sqlite3VdbeMemSetNull(pMem-1);
90175 Mem *pMem = &v->aVar[iVar-1];
90178 if( 0==(pMem->flags & MEM_Null) ){
90181 sqlite3VdbeMemCopy((Mem *)pRet, pMem);
90286 Mem *pMem = &p->aMem[i];
90287 if( pMem->zMalloc ) sqlite3VdbeMemReleaseMalloc(pMem);
90588 Mem *pMem = (Mem*)pVal;
90589 return ((pMem->flags & MEM_Subtype) ? pMem->eSubtype : 0);
91486 Mem *pMem = p->pMem;
91487 assert( (pMem->flags & MEM_Agg)==0 );
91489 sqlite3VdbeMemSetNull(pMem);
91490 pMem->z = 0;
91492 sqlite3VdbeMemClearAndResize(pMem, nByte);
91493 pMem->flags = MEM_Agg;
91494 pMem->u.pDef = p->pFunc;
91495 if( pMem->z ){
91496 memset(pMem->z, 0, nByte);
91499 return (void*)pMem->z;
91511 if( (p->pMem->flags & MEM_Agg)==0 ){
91514 return (void*)p->pMem->z;
91617 assert( p && p->pMem && p->pFunc && p->pFunc->xFinalize );
91618 return p->pMem->n;
92536 Mem *pMem;
92580 pMem = *ppValue = &p->pUnpacked->aMem[iIdx];
92582 sqlite3VdbeMemSetInt64(pMem, p->iKey1);
92586 if( pMem->flags & (MEM_Int|MEM_IntReal) ){
92587 testcase( pMem->flags & MEM_Int );
92588 testcase( pMem->flags & MEM_IntReal );
92589 sqlite3VdbeMemRealify(pMem);
92662 Mem *pMem;
92697 pMem = &pUnpack->aMem[iIdx];
92699 sqlite3VdbeMemSetInt64(pMem, p->iKey2);
92701 pMem = (sqlite3_value *)columnNullValue();
92718 pMem = &p->aNew[iIdx];
92719 if( pMem->flags==0 ){
92721 sqlite3VdbeMemSetInt64(pMem, p->iKey2);
92723 rc = sqlite3VdbeMemCopy(pMem, &p->v->aMem[p->iNewReg+1+iIdx]);
92728 *ppValue = pMem;
93381 Mem *pMem = iCur>0 ? &p->aMem[p->nMem-iCur] : p->aMem;
93399 assert( pMem->flags==MEM_Undefined );
93400 assert( (pMem->flags & MEM_Dyn)==0 );
93401 assert( pMem->szMalloc==0 || pMem->z==pMem->zMalloc );
93402 if( pMem->szMalloc<nByte ){
93403 if( pMem->szMalloc>0 ){
93404 sqlite3DbFreeNN(pMem->db, pMem->zMalloc);
93406 pMem->z = pMem->zMalloc = sqlite3DbMallocRaw(pMem->db, nByte);
93407 if( pMem->zMalloc==0 ){
93408 pMem->szMalloc = 0;
93411 pMem->szMalloc = nByte;
93414 p->apCsr[iCur] = pCx = (VdbeCursor*)pMem->zMalloc;
93421 &pMem->z[ROUND8P(sizeof(VdbeCursor))+2*sizeof(u32)*nField];
93544 Mem *pMem = (Mem*)pVal;
93545 applyNumericAffinity(pMem, 0);
93569 static u16 SQLITE_NOINLINE computeNumericType(Mem *pMem){
93572 assert( (pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal))==0 );
93573 assert( (pMem->flags & (MEM_Str|MEM_Blob))!=0 );
93574 if( ExpandBlob(pMem) ){
93575 pMem->u.i = 0;
93578 rc = sqlite3AtoF(pMem->z, &pMem->u.r, pMem->n, pMem->enc);
93580 if( rc==0 && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)<=1 ){
93581 pMem->u.i = ix;
93586 }else if( rc==1 && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)==0 ){
93587 pMem->u.i = ix;
93600 static u16 numericType(Mem *pMem){
93601 assert( (pMem->flags & MEM_Null)==0
93602 || pMem->db==0 || pMem->db->mallocFailed );
93603 if( pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Null) ){
93604 testcase( pMem->flags & MEM_Int );
93605 testcase( pMem->flags & MEM_Real );
93606 testcase( pMem->flags & MEM_IntReal );
93607 return pMem->flags & (MEM_Int|MEM_Real|MEM_IntReal|MEM_Null);
93609 assert( pMem->flags & (MEM_Str|MEM_Blob) );
93610 testcase( pMem->flags & MEM_Str );
93611 testcase( pMem->flags & MEM_Blob );
93612 return computeNumericType(pMem);
93621 SQLITE_PRIVATE void sqlite3VdbeMemPrettyPrint(Mem *pMem, StrAccum *pStr){
93622 int f = pMem->flags;
93640 for(i=0; i<25 && i<pMem->n; i++){
93641 sqlite3_str_appendf(pStr, "%02X", ((int)pMem->z[i] & 0xFF));
93644 for(i=0; i<25 && i<pMem->n; i++){
93645 char z = pMem->z[i];
93650 sqlite3_str_appendf(pStr, "+%dz",pMem->u.nZero);
93667 sqlite3_str_appendf(pStr, " %c%d[", c, pMem->n);
93668 for(j=0; j<25 && j<pMem->n; j++){
93669 c = pMem->z[j];
93672 sqlite3_str_appendf(pStr, "]%s", encnames[pMem->enc]);
93719 /**/ void sqlite3PrintMem(Mem *pMem){
93720 memTracePrint(pMem);
93902 static const char *vdbeMemTypeName(Mem *pMem){
93910 return azTypes[sqlite3_value_type(pMem)-1];
94813 Mem *pMem = p->pResultRow;
94816 assert( memIsValid(&pMem[i]) );
94817 REGISTER_TRACE(pOp->p1+i, &pMem[i]);
94823 pMem[i].pScopyFrom = 0;
96216 sqlite3VdbeMemShallowCopy(pDest, pOp->p4.pMem, MEM_Static);
98614 Mem *pMem; /* Register holding largest rowid for AUTOINCREMENT */
98679 pMem = &pFrame->aMem[pOp->p3];
98683 pMem = &aMem[pOp->p3];
98684 memAboutToChange(p, pMem);
98686 assert( memIsValid(pMem) );
98688 REGISTER_TRACE(pOp->p3, pMem);
98689 sqlite3VdbeMemIntegerify(pMem);
98690 assert( (pMem->flags & MEM_Int)!=0 ); /* mem(P3) holds an integer */
98691 if( pMem->u.i==MAX_ROWID || pC->useRandomRowid ){
98695 if( v<pMem->u.i+1 ){
98696 v = pMem->u.i + 1;
98698 pMem->u.i = v;
100413 Mem *pMem; /* Used to iterate through memory cells */
100489 for(pMem=VdbeFrameMem(pFrame); pMem!=pEnd; pMem++){
100490 pMem->flags = MEM_Undefined;
100491 pMem->db = db;
100783 pCtx->pMem = 0;
100806 Mem *pMem;
100810 pMem = &aMem[pOp->p3];
100816 assert( pMem->uTemp==0x1122e0e3 );
100819 pMem->uTemp = 0x1122e0e3;
100827 if( pCtx->pMem != pMem ){
100828 pCtx->pMem = pMem;
100839 pMem->n++;
100899 Mem *pMem;
100902 pMem = &aMem[pOp->p1];
100903 assert( (pMem->flags & ~(MEM_Null|MEM_Agg))==0 );
100907 rc = sqlite3VdbeMemAggValue(pMem, &aMem[pOp->p3], pOp->p4.pFunc);
100908 pMem = &aMem[pOp->p3];
100912 rc = sqlite3VdbeMemFinalize(pMem, pOp->p4.pFunc);
100916 sqlite3VdbeError(p, "%s", sqlite3_value_text(pMem));
100919 sqlite3VdbeChangeEncoding(pMem, encoding);
100920 UPDATE_MAX_BLOBSIZE(pMem);
100921 REGISTER_TRACE((int)(pMem-aMem), pMem);
100940 Mem *pMem; /* Write results here */
100956 for(i=0, pMem = &aMem[pOp->p3]; i<3; i++, pMem++){
100957 sqlite3VdbeMemSetInt64(pMem, (i64)aRes[i]);
102100 Mem *pMem;
102105 pMem = &aMem[pOp->p1];
102107 for(i=0; i<pOp->p2; i++, pMem++){
102109 pMem->pScopyFrom = 0;
102110 if( i<32 && pOp->p5 ) MemSetTypeFlag(pMem, MEM_Undefined);