Lines Matching refs:pOut
10844 void *pOut /* Result written here */
10851 void *pOut /* Result written here */
13242 int (*xOutput)(void *pOut, const void *pData, int nData),
13243 void *pOut
13248 int (*xOutput)(void *pOut, const void *pData, int nData),
13249 void *pOut
13264 int (*xOutput)(void *pOut, const void *pData, int nData),
13265 void *pOut
13269 int (*xOutput)(void *pOut, const void *pData, int nData),
13270 void *pOut
13277 int (*xOutput)(void *pOut, const void *pData, int nData),
13278 void *pOut
13284 int (*xOutput)(void *pOut, const void *pData, int nData),
13285 void *pOut
23977 Mem *pOut; /* The return value is stored here */ member
24159 sqlite3_value *pOut; /* Register to hold each decoded output value */ member
34679 void *pOut; /* Result returned by the thread */ member
34715 p->pOut = xTask(pIn); in sqlite3ThreadCreate()
34728 *ppOut = p->pOut; in sqlite3ThreadJoin()
35847 char *pOut = p->u.zToken; in sqlite3DequoteNumber() local
35854 *pOut++ = *pIn; in sqlite3DequoteNumber()
36412 SQLITE_PRIVATE int sqlite3DecOrHexToI64(const char *z, i64 *pOut){ in sqlite3DecOrHexToI64() argument
36423 memcpy(pOut, &u, 8); in sqlite3DecOrHexToI64()
36432 return sqlite3Atoi64(z, pOut, n, SQLITE_UTF8); in sqlite3DecOrHexToI64()
37325 VList *pOut = sqlite3DbRealloc(db, pIn, nAlloc*sizeof(int)); in sqlite3VListAdd() local
37326 if( pOut==0 ) return pIn; in sqlite3VListAdd()
37327 if( pIn==0 ) pOut[1] = 2; in sqlite3VListAdd()
37328 pIn = pOut; in sqlite3VListAdd()
54576 unsigned char *pOut; local
54597 pOut = pStore->aData;
54599 pOut = sqlite3_malloc64( pStore->sz );
54600 if( pOut ) memcpy(pOut, pStore->aData, pStore->sz);
54602 return pOut;
54613 pOut = 0;
54626 pOut = 0;
54628 pOut = sqlite3_malloc64( sz );
54629 if( pOut ){
54635 unsigned char *pTo = pOut + szPage*(sqlite3_int64)(pgno-1);
54648 return pOut;
69517 u8 *pOut /* Buffer to write page data to */
69527 return sqlite3OsRead(pWal->pWalFd, pOut, (nOut>sz ? sz : nOut), iOffset);
79515 u8 *pOut = &pSpace[4]; local
79571 while( ((*(pOut++) = *(pCell++))&0x80) && pCell<pStop );
79575 rc = insertCell(pParent, pParent->nCell, pSpace, (int)(pOut-pSpace),
82302 static int btreeHeapPull(u32 *aHeap, u32 *pOut){
82305 *pOut = aHeap[1];
84342 ctx.pOut = &t;
84362 SQLITE_PRIVATE int sqlite3VdbeMemAggValue(Mem *pAccum, Mem *pOut, FuncDef *pFunc){
84370 sqlite3VdbeMemSetNull(pOut);
84371 ctx.pOut = pOut;
85389 ctx.pOut = pVal;
86352 pCtx->pOut = 0;
87044 VdbeOp *pOut, *pFirst; local
87050 pFirst = pOut = &p->aOp[p->nOp];
87051 for(i=0; i<nOp; i++, aOp++, pOut++){
87052 pOut->opcode = aOp->opcode;
87053 pOut->p1 = aOp->p1;
87054 pOut->p2 = aOp->p2;
87057 pOut->p2 += p->nOp;
87059 pOut->p3 = aOp->p3;
87060 pOut->p4type = P4_NOTUSED;
87061 pOut->p4.p = 0;
87062 pOut->p5 = 0;
87064 pOut->zComment = 0;
87067 pOut->iSrcLine = iLineno+i;
88002 SQLITE_PRIVATE void sqlite3VdbePrintOp(FILE *pOut, int pc, VdbeOp *pOp){
88007 if( pOut==0 ) pOut = stdout;
88019 fprintf(pOut, zFormat1, pc,
88024 fflush(pOut);
91854 Mem *pOut = pCtx->pOut; local
91855 int rc = sqlite3VdbeMemSetStr(pOut, z, n, enc, xDel);
91867 sqlite3VdbeChangeEncoding(pOut, pCtx->enc);
91868 if( sqlite3VdbeMemTooBig(pOut) ){
91908 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
91924 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
91935 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
91936 sqlite3VdbeMemSetDouble(pCtx->pOut, rVal);
91942 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
91944 sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);
91951 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
91953 sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);
91960 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
91961 sqlite3VdbeMemSetInt64(pCtx->pOut, (i64)iVal);
91967 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
91968 sqlite3VdbeMemSetInt64(pCtx->pOut, iVal);
91974 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
91975 sqlite3VdbeMemSetNull(pCtx->pOut);
91983 Mem *pOut; local
91990 pOut = pCtx->pOut;
91991 assert( sqlite3_mutex_held(pOut->db->mutex) );
91992 sqlite3VdbeMemRelease(pOut);
91993 pOut->flags = MEM_Null;
91994 sqlite3VdbeMemSetPointer(pOut, pPtr, zPType, xDestructor);
91997 Mem *pOut; local
92013 pOut = pCtx->pOut;
92014 assert( sqlite3_mutex_held(pOut->db->mutex) );
92015 pOut->eSubtype = eSubtype & 0xff;
92016 pOut->flags |= MEM_Subtype;
92030 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
92046 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
92056 sqlite3VdbeMemZeroTerminateIfAble(pCtx->pOut);
92066 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
92075 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
92084 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
92089 Mem *pOut; local
92098 pOut = pCtx->pOut;
92099 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
92100 sqlite3VdbeMemCopy(pOut, pValue);
92101 sqlite3VdbeChangeEncoding(pOut, pCtx->enc);
92102 if( sqlite3VdbeMemTooBig(pOut) ){
92110 Mem *pOut; local
92115 pOut = pCtx->pOut;
92116 assert( sqlite3_mutex_held(pOut->db->mutex) );
92117 if( n>(u64)pOut->db->aLimit[SQLITE_LIMIT_LENGTH] ){
92122 sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n);
92125 return sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n);
92136 if( pCtx->pOut->flags & MEM_Null ){
92147 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
92149 sqlite3VdbeMemSetStr(pCtx->pOut, "string or blob too big", -1,
92158 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
92159 sqlite3VdbeMemSetNull(pCtx->pOut);
92161 sqlite3OomFault(pCtx->pOut->db);
92170 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
92171 if( pCtx->pOut->flags & MEM_Int ){
92172 pCtx->pOut->flags &= ~MEM_Int;
92173 pCtx->pOut->flags |= MEM_IntReal;
92431 assert( p && p->pOut );
92433 return p->pOut->db;
92456 return sqlite3_value_nochange(p->pOut);
92510 sqlite3_value *pOut = pRhs->pOut; local
92512 sqlite3VdbeSerialGet(&zBuf[iOff], iSerial, pOut);
92513 pOut->enc = ENC(pOut->db);
92514 if( (pOut->flags & MEM_Ephem)!=0 && sqlite3VdbeMemMakeWriteable(pOut) ){
92517 *ppOut = pOut;
92558 rc = sqlite3OsCurrentTimeInt64(p->pOut->db->pVfs, piTime);
92592 assert( sqlite3_mutex_held(p->pOut->db->mutex) );
92617 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
92655 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
92770 Mem *pOut; local
92777 pOut = &pVm->pResultRow[i];
92780 pOut = (Mem*)columnNullValue();
92782 return pOut;
92864 Mem *pOut = columnMem(pStmt, i); local
92865 if( pOut->flags&MEM_Static ){
92866 pOut->flags &= ~MEM_Static;
92867 pOut->flags |= MEM_Ephem;
92870 return (sqlite3_value *)pOut;
93883 void *pOut /* OUT: Write the answer here */
93892 if( p==0 || pOut==0
93914 *(i64*)pOut = res;
93939 *(sqlite3_int64*)pOut = aOp[pScan->addrLoop].nExec;
93941 *(sqlite3_int64*)pOut = -1;
93947 *(sqlite3_int64*)pOut = aOp[pScan->addrVisit].nExec;
93949 *(sqlite3_int64*)pOut = -1;
93960 *(double*)pOut = r*sqlite3LogEstToInt(x);
93964 *(const char**)pOut = pScan->zName;
93969 *(const char**)pOut = aOp[ pScan->addrExplain ].p4.z;
93971 *(const char**)pOut = 0;
93977 *(int*)pOut = aOp[ pScan->addrExplain ].p1;
93979 *(int*)pOut = -1;
93985 *(int*)pOut = aOp[ pScan->addrExplain ].p2;
93987 *(int*)pOut = -1;
94019 *(i64*)pOut = res;
94036 void *pOut /* OUT: Write the answer here */
94038 return sqlite3_stmt_scanstatus_v2(pStmt, iScan, iScanStatusOp, 0, pOut);
95005 static SQLITE_NOINLINE Mem *out2PrereleaseWithClear(Mem *pOut){
95006 sqlite3VdbeMemSetNull(pOut);
95007 pOut->flags = MEM_Int;
95008 return pOut;
95011 Mem *pOut;
95014 pOut = &p->aMem[pOp->p2];
95015 memAboutToChange(p, pOut);
95016 if( VdbeMemDynamic(pOut) ){ /*OPTIMIZATION-IF-FALSE*/
95017 return out2PrereleaseWithClear(pOut);
95019 pOut->flags = MEM_Int;
95020 return pOut;
95177 Mem *pOut = 0; /* Output operand */
95486 pOut = &aMem[pOp->p1];
95487 assert( !VdbeMemDynamic(pOut) );
95488 pOut->u.i = pOp->p3 - 1;
95489 pOut->flags = MEM_Int;
95681 pOut = out2Prerelease(p, pOp);
95682 pOut->u.i = pOp->p1;
95693 pOut = out2Prerelease(p, pOp);
95695 pOut->u.i = *pOp->p4.pI64;
95707 pOut = out2Prerelease(p, pOp);
95708 pOut->flags = MEM_Real;
95710 pOut->u.r = *pOp->p4.pReal;
95725 pOut = out2Prerelease(p, pOp);
95730 rc = sqlite3VdbeMemSetStr(pOut, pOp->p4.z, -1, SQLITE_UTF8, SQLITE_STATIC);
95733 if( SQLITE_OK!=sqlite3VdbeChangeEncoding(pOut, encoding) ) goto no_mem;
95734 assert( pOut->szMalloc>0 && pOut->zMalloc==pOut->z );
95735 assert( VdbeMemDynamic(pOut)==0 );
95736 pOut->szMalloc = 0;
95737 pOut->flags |= MEM_Static;
95742 pOp->p4.z = pOut->z;
95743 pOp->p1 = pOut->n;
95769 pOut = out2Prerelease(p, pOp);
95770 pOut->flags = MEM_Str|MEM_Static|MEM_Term;
95771 pOut->z = pOp->p4.z;
95772 pOut->n = pOp->p1;
95773 pOut->enc = encoding;
95774 UPDATE_MAX_BLOBSIZE(pOut);
95780 if( pIn3->u.i==pOp->p5 ) pOut->flags = MEM_Blob|MEM_Static|MEM_Term;
95824 pOut = out2Prerelease(p, pOp);
95827 pOut->flags = nullFlag = pOp->p1 ? (MEM_Null|MEM_Cleared) : MEM_Null;
95828 pOut->n = 0;
95830 pOut->uTemp = 0;
95833 pOut++;
95834 memAboutToChange(p, pOut);
95835 sqlite3VdbeMemSetNull(pOut);
95836 pOut->flags = nullFlag;
95837 pOut->n = 0;
95853 pOut = &aMem[pOp->p1];
95854 pOut->flags = (pOut->flags&~(MEM_Undefined|MEM_AffMask))|MEM_Null;
95867 pOut = out2Prerelease(p, pOp);
95869 sqlite3VdbeMemSetZeroBlob(pOut, pOp->p1);
95870 if( sqlite3VdbeMemExpandBlob(pOut) ) goto no_mem;
95872 sqlite3VdbeMemSetStr(pOut, pOp->p4.z, pOp->p1, 0, 0);
95874 pOut->enc = encoding;
95875 UPDATE_MAX_BLOBSIZE(pOut);
95892 pOut = &aMem[pOp->p2];
95893 if( VdbeMemDynamic(pOut) ) sqlite3VdbeMemSetNull(pOut);
95894 memcpy(pOut, pVar, MEMCELLSIZE);
95895 pOut->flags &= ~(MEM_Dyn|MEM_Ephem);
95896 pOut->flags |= MEM_Static|MEM_FromBind;
95897 UPDATE_MAX_BLOBSIZE(pOut);
95922 pOut = &aMem[p2];
95924 assert( pOut<=&aMem[(p->nMem+1 - p->nCursor)] );
95927 memAboutToChange(p, pOut);
95928 sqlite3VdbeMemMove(pOut, pIn1);
95935 aMem[i].pScopyFrom = pOut;
95940 Deephemeralize(pOut);
95941 REGISTER_TRACE(p2++, pOut);
95943 pOut++;
95966 pOut = &aMem[pOp->p2];
95967 assert( pOut!=pIn1 );
95969 memAboutToChange(p, pOut);
95970 sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem);
95971 Deephemeralize(pOut);
95972 if( (pOut->flags & MEM_Subtype)!=0 && (pOp->p5 & 0x0002)!=0 ){
95973 pOut->flags &= ~MEM_Subtype;
95976 pOut->pScopyFrom = 0;
95978 REGISTER_TRACE(pOp->p2+pOp->p3-n, pOut);
95980 pOut++;
96001 pOut = &aMem[pOp->p2];
96002 assert( pOut!=pIn1 );
96003 sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem);
96005 pOut->pScopyFrom = pIn1;
96006 pOut->mScopyFlags = pIn1->flags;
96023 pOut = &aMem[pOp->p2];
96024 sqlite3VdbeMemSetInt64(pOut, pIn1->u.i);
96107 pOut = &aMem[pOp->p3];
96108 testcase( pOut==pIn2 );
96109 assert( pIn1!=pOut );
96114 sqlite3VdbeMemSetNull(pOut);
96136 if( sqlite3VdbeMemGrow(pOut, (int)nByte+2, pOut==pIn2) ){
96139 MemSetTypeFlag(pOut, MEM_Str);
96140 if( pOut!=pIn2 ){
96141 memcpy(pOut->z, pIn2->z, pIn2->n);
96145 memcpy(&pOut->z[pIn2->n], pIn1->z, pIn1->n);
96149 pOut->z[nByte]=0;
96150 pOut->z[nByte+1] = 0;
96151 pOut->flags |= MEM_Term;
96152 pOut->n = (int)nByte;
96153 pOut->enc = encoding;
96154 UPDATE_MAX_BLOBSIZE(pOut);
96212 pOut = &aMem[pOp->p3];
96234 pOut->u.i = iB;
96235 MemSetTypeFlag(pOut, MEM_Int);
96265 pOut->u.i = rB;
96266 MemSetTypeFlag(pOut, MEM_Int);
96271 pOut->u.r = rB;
96272 MemSetTypeFlag(pOut, MEM_Real);
96278 sqlite3VdbeMemSetNull(pOut);
96346 pOut = &aMem[pOp->p3];
96348 sqlite3VdbeMemSetNull(pOut);
96382 pOut->u.i = iA;
96383 MemSetTypeFlag(pOut, MEM_Int);
96912 pOut = &aMem[pOp->p3];
96914 MemSetTypeFlag(pOut, MEM_Null);
96916 pOut->u.i = v1;
96917 MemSetTypeFlag(pOut, MEM_Int);
96960 pOut = &aMem[pOp->p2];
96962 sqlite3VdbeMemSetInt64(pOut, !sqlite3VdbeBooleanValue(pIn1,0));
96964 sqlite3VdbeMemSetNull(pOut);
96978 pOut = &aMem[pOp->p2];
96979 sqlite3VdbeMemSetNull(pOut);
96981 pOut->flags = MEM_Int;
96982 pOut->u.i = ~sqlite3VdbeIntValue(pIn1);
97239 pOut = &p->aMem[pOp->p3];
97241 sqlite3VdbeMemSetNull(pOut);
97248 sqlite3VdbeMemSetNull(pOut);
97250 sqlite3VdbeMemSetInt64(pOut, sqlite3BtreeOffset(pC->uc.pCursor));
97795 pOut = &aMem[pOp->p3];
97796 memAboutToChange(p, pOut);
97973 if( nByte+nZero<=pOut->szMalloc ){
97976 pOut->z = pOut->zMalloc;
97983 if( sqlite3VdbeMemClearAndResize(pOut, (int)nByte) ){
97987 pOut->n = (int)nByte;
97988 pOut->flags = MEM_Blob;
97990 pOut->u.nZero = nZero;
97991 pOut->flags |= MEM_Zero;
97993 UPDATE_MAX_BLOBSIZE(pOut);
97994 zHdr = (u8 *)pOut->z;
98062 assert( nHdr==(int)(zHdr - (u8*)pOut->z) );
98063 assert( nByte==(int)(zPayload - (u8*)pOut->z) );
98066 REGISTER_TRACE(pOp->p3, pOut);
98094 pOut = out2Prerelease(p, pOp);
98095 pOut->u.i = nEntry;
98512 pOut = out2Prerelease(p, pOp);
98513 pOut->u.i = iMeta;
99851 pOut = out2Prerelease(p, pOp);
99852 pOut->u.i = p->apCsr[pOp->p1]->seqCount++;
99884 pOut = out2Prerelease(p, pOp);
99990 pOut->u.i = v;
100348 pOut = &aMem[pOp->p2];
100351 rc = sqlite3VdbeSorterRowkey(pC, pOut);
100352 assert( rc!=SQLITE_OK || (pOut->flags & MEM_Blob) );
100392 pOut = out2Prerelease(p, pOp);
100419 rc = sqlite3VdbeMemFromBtreeZeroOffset(pCrsr, n, pOut);
100421 if( !pOp->p3 ) Deephemeralize(pOut);
100422 UPDATE_MAX_BLOBSIZE(pOut);
100423 REGISTER_TRACE(pOp->p2, pOut);
100443 pOut = out2Prerelease(p, pOp);
100449 pOut->flags = MEM_Null;
100469 pOut->flags = MEM_Null;
100474 pOut->u.i = v;
101006 pOut = out2Prerelease(p, pOp);
101007 pOut->u.i = rowid;
101186 pOut = out2Prerelease(p, pOp);
101187 pOut->flags = MEM_Null;
101197 pOut->flags = MEM_Int;
101198 pOut->u.i = iMoved;
101288 pOut = out2Prerelease(p, pOp);
101298 pOut->u.i = pgno;
101814 pOut = out2Prerelease(p, pOp);
101817 sqlite3VdbeMemShallowCopy(pOut, pIn, MEM_Ephem);
101943 pOut = out2Prerelease(p, pOp);
101955 pOut->u.i = -1;
101957 pOut->u.i = x;
102058 pCtx->pOut = (Mem*)((u8*)pCtx + nAlloc);
102059 assert( EIGHT_BYTE_ALIGNMENT(pCtx->pOut) );
102061 sqlite3VdbeMemInit(pCtx->pOut, db, MEM_Null);
102117 assert( pCtx->pOut->flags==MEM_Null );
102129 sqlite3VdbeError(p, "%s", sqlite3_value_text(pCtx->pOut));
102138 sqlite3VdbeMemRelease(pCtx->pOut);
102139 pCtx->pOut->flags = MEM_Null;
102143 assert( pCtx->pOut->flags==MEM_Null );
102261 pOut = out2Prerelease(p, pOp);
102336 pOut->flags = MEM_Str|MEM_Static|MEM_Term;
102337 pOut->z = (char *)sqlite3JournalModename(eNew);
102338 pOut->n = sqlite3Strlen30(pOut->z);
102339 pOut->enc = SQLITE_UTF8;
102340 sqlite3VdbeChangeEncoding(pOut, encoding);
102606 pOut = &aMem[pOp->p2];
102607 sqlite3VdbeMemSetNull(pOut); /* Innocent until proven guilty */
102630 sqlite3VdbeMemSetStr(pOut, zErr, -1, SQLITE_UTF8, sqlite3_free);
102655 pRhs->pOut = &aMem[pOp->p3];
102656 pOut = out2Prerelease(p, pOp);
102657 pOut->flags = MEM_Null;
102658 sqlite3VdbeMemSetPointer(pOut, pRhs, "ValueList", sqlite3VdbeValueListFree);
102766 sContext.pOut = pDest;
102962 pOut = out2Prerelease(p, pOp);
102963 pOut->u.i = sqlite3BtreeLastPage(db->aDb[pOp->p1].pBt);
102982 pOut = out2Prerelease(p, pOp);
102989 pOut->u.i = sqlite3BtreeMaxPageCount(pBt, newMax);
103052 pOut = &aMem[pOp->p3];
103053 if( pCtx->pOut != pOut ){
103055 pCtx->pOut = pOut;
103061 memAboutToChange(p, pOut);
103068 MemSetTypeFlag(pOut, MEM_Null);
103075 sqlite3VdbeError(p, "%s", sqlite3_value_text(pOut));
103083 assert( (pOut->flags&MEM_Str)==0
103084 || pOut->enc==encoding
103086 assert( !sqlite3VdbeMemTooBig(pOut) );
103088 REGISTER_TRACE(pOp->p3, pOut);
103089 UPDATE_MAX_BLOBSIZE(pOut);
103112 pOut = &aMem[pOp->p2];
103114 sqlite3VdbeMemSetInt64(pOut, pIn1->eSubtype);
103116 sqlite3VdbeMemSetNull(pOut);
103129 pOut = &aMem[pOp->p2];
103131 pOut->flags &= ~MEM_Subtype;
103134 pOut->flags |= MEM_Subtype;
103135 pOut->eSubtype = (u8)(pIn1->u.i & 0xff);
105992 SorterFile *pOut = &pIncr->aFile[1];
106000 vdbePmaWriterInit(pOut->pFd, &writer, pTask->pSorter->pgsz, iStart);
106019 rc2 = vdbePmaWriterFinish(&writer, &pOut->iEof);
106808 SQLITE_PRIVATE int sqlite3VdbeSorterRowkey(const VdbeCursor *pCsr, Mem *pOut){
106815 if( sqlite3VdbeMemClearAndResize(pOut, nKey) ){
106818 pOut->n = nKey;
106819 MemSetTypeFlag(pOut, MEM_Blob);
106820 memcpy(pOut->z, pKey, nKey);
157279 sqlite3_value *pOut /* Write results here, if not NULL. VACUUM INTO */
157310 if( pOut ){
157311 if( sqlite3_value_type(pOut)!=SQLITE_TEXT ){
157315 zOut = (const char*)sqlite3_value_text(pOut);
157364 if( pOut ){
157391 rc = sqlite3BtreeBeginTrans(pMain, pOut==0 ? 2 : 0, 0);
157397 && pOut==0
157488 assert( pOut!=0 || SQLITE_TXN_WRITE==sqlite3BtreeTxnState(pMain) );
157499 if( pOut==0 ){
157506 if( pOut==0 ){
157513 if( pOut==0 ){
191847 char *pOut /* Write output here */
191856 nOut += sqlite3Fts3PutVarint(&pOut[nOut], iDelta);
191857 pOut[nOut++] = 0x02;
191869 nOut += sqlite3Fts3PutVarint(&pOut[nOut], iDelta);
191872 pOut[nOut++] = 0x01;
191873 nOut += sqlite3Fts3PutVarint(&pOut[nOut], iCol);
191874 pOut[nOut++] = 0x02;
191879 pOut[nOut++] = 0x00;
193894 char *pOut = aDoclist;
193896 int res = fts3PoslistPhraseMerge(&pOut, nDist, 0, 1, &pL, &pR);
193898 nList = (int)(pOut - aDoclist);
194357 char *pOut;
194362 p2 = pOut = pPhrase->doclist.pList;
194364 &pOut, aTmp, nParam1, nParam2, paPoslist, &p2
194367 nNew = (int)(pOut - pPhrase->doclist.pList) - 1;
206009 StrBuffer *pOut /* Write output here */
206065 rc = fts3StringAppend(pOut, &zDoc[iEnd], -1);
206084 rc = fts3StringAppend(pOut, zEllipsis, -1);
206086 rc = fts3StringAppend(pOut, zDoc, iBegin);
206094 rc = fts3StringAppend(pOut, zEllipsis, -1);
206102 if( iCurrent>iPos ) rc = fts3StringAppend(pOut, &zDoc[iEnd], iBegin-iEnd);
206103 if( rc==SQLITE_OK && isHighlight ) rc = fts3StringAppend(pOut, zOpen, -1);
206104 if( rc==SQLITE_OK ) rc = fts3StringAppend(pOut, &zDoc[iBegin], iFin-iBegin);
206105 if( rc==SQLITE_OK && isHighlight ) rc = fts3StringAppend(pOut, zClose, -1);
210030 JsonString *pOut /* Write JSON here */
210036 pOut->eErr |= JSTRING_MALFORMED;
210041 jsonAppendRawNZ(pOut, "null", 4);
210045 jsonAppendRawNZ(pOut, "true", 4);
210049 jsonAppendRawNZ(pOut, "false", 5);
210055 jsonAppendRaw(pOut, (const char*)&pParse->aBlob[i+n], sz);
210065 jsonAppendChar(pOut, '-');
210072 pOut->eErr |= JSTRING_MALFORMED;
210080 jsonPrintf(100,pOut,bOverflow?"9.0e999":"%llu", u);
210088 jsonAppendChar(pOut, '-');
210092 jsonAppendChar(pOut, '0');
210095 jsonAppendChar(pOut, zIn[k]);
210097 jsonAppendChar(pOut, '0');
210104 if( pOut->nUsed+sz+2<=pOut->nAlloc || jsonStringGrow(pOut, sz+2)==0 ){
210105 pOut->zBuf[pOut->nUsed] = '"';
210106 memcpy(pOut->zBuf+pOut->nUsed+1,(const char*)&pParse->aBlob[i+n],sz);
210107 pOut->zBuf[pOut->nUsed+sz+1] = '"';
210108 pOut->nUsed += sz+2;
210117 jsonAppendChar(pOut, '"');
210121 jsonAppendRawNZ(pOut, zIn, k);
210129 jsonAppendRawNZ(pOut, "\\\"", 2);
210135 if( pOut->nUsed+7>pOut->nAlloc && jsonStringGrow(pOut,7) ) break;
210136 jsonAppendControlChar(pOut, zIn[0]);
210144 pOut->eErr |= JSTRING_MALFORMED;
210149 jsonAppendChar(pOut, '\'');
210152 jsonAppendRawNZ(pOut, "\\u0009", 6);
210156 pOut->eErr |= JSTRING_MALFORMED;
210160 jsonAppendRawNZ(pOut, "\\u00", 4);
210161 jsonAppendRawNZ(pOut, &zIn[2], 2);
210166 jsonAppendRawNZ(pOut, "\\u0000", 6);
210184 pOut->eErr |= JSTRING_MALFORMED;
210192 jsonAppendRawNZ(pOut, zIn, 2);
210199 jsonAppendChar(pOut, '"');
210203 jsonAppendString(pOut, (const char*)&pParse->aBlob[i+n], sz);
210207 jsonAppendChar(pOut, '[');
210210 while( j<iEnd && pOut->eErr==0 ){
210211 j = jsonTranslateBlobToText(pParse, j, pOut);
210212 jsonAppendChar(pOut, ',');
210214 if( j>iEnd ) pOut->eErr |= JSTRING_MALFORMED;
210215 if( sz>0 ) jsonStringTrimOneChar(pOut);
210216 jsonAppendChar(pOut, ']');
210221 jsonAppendChar(pOut, '{');
210224 while( j<iEnd && pOut->eErr==0 ){
210225 j = jsonTranslateBlobToText(pParse, j, pOut);
210226 jsonAppendChar(pOut, (x++ & 1) ? ',' : ':');
210228 if( (x & 1)!=0 || j>iEnd ) pOut->eErr |= JSTRING_MALFORMED;
210229 if( sz>0 ) jsonStringTrimOneChar(pOut);
210230 jsonAppendChar(pOut, '}');
210236 pOut->eErr |= JSTRING_MALFORMED;
210248 JsonString *pOut; /* Generate pretty output into this string */
210258 jsonAppendRaw(pPretty->pOut, pPretty->zIndent, pPretty->szIndent);
210285 JsonString *pOut = pPretty->pOut;
210288 pOut->eErr |= JSTRING_MALFORMED;
210295 jsonAppendChar(pOut, '[');
210297 jsonAppendChar(pOut, '\n');
210299 while( pOut->eErr==0 ){
210303 jsonAppendRawNZ(pOut, ",\n", 2);
210305 jsonAppendChar(pOut, '\n');
210309 jsonAppendChar(pOut, ']');
210316 jsonAppendChar(pOut, '{');
210318 jsonAppendChar(pOut, '\n');
210320 while( pOut->eErr==0 ){
210322 j = jsonTranslateBlobToText(pParse, j, pOut);
210324 pOut->eErr |= JSTRING_MALFORMED;
210327 jsonAppendRawNZ(pOut, ": ", 2);
210330 jsonAppendRawNZ(pOut, ",\n", 2);
210332 jsonAppendChar(pOut, '\n');
210336 jsonAppendChar(pOut, '}');
210341 i = jsonTranslateBlobToText(pParse, i, pOut);
211563 sqlite3_str *pOut /* Generate output into this sqlite3_str object */
211570 sqlite3_str_appendf(pOut, "%5d:%*s", iStart, nIndent, "");
211580 sqlite3_str_appendf(pOut, " %02x", pParse->aBlob[iStart+i]);
211583 sqlite3_str_appendf(pOut, " ERROR invalid node size\n");
211598 sqlite3_str_appendall(pOut," <-- ");
211600 case JSONB_NULL: sqlite3_str_appendall(pOut,"null"); break;
211601 case JSONB_TRUE: sqlite3_str_appendall(pOut,"true"); break;
211602 case JSONB_FALSE: sqlite3_str_appendall(pOut,"false"); break;
211603 case JSONB_INT: sqlite3_str_appendall(pOut,"int"); break;
211604 case JSONB_INT5: sqlite3_str_appendall(pOut,"int5"); break;
211605 case JSONB_FLOAT: sqlite3_str_appendall(pOut,"float"); break;
211606 case JSONB_FLOAT5: sqlite3_str_appendall(pOut,"float5"); break;
211607 case JSONB_TEXT: sqlite3_str_appendall(pOut,"text"); break;
211608 case JSONB_TEXTJ: sqlite3_str_appendall(pOut,"textj"); break;
211609 case JSONB_TEXT5: sqlite3_str_appendall(pOut,"text5"); break;
211610 case JSONB_TEXTRAW: sqlite3_str_appendall(pOut,"textraw"); break;
211612 sqlite3_str_appendf(pOut,"array, %u bytes\n", sz);
211613 jsonDebugPrintBlob(pParse, iStart+n, iStart+n+sz, nIndent+2, pOut);
211618 sqlite3_str_appendf(pOut, "object, %u bytes\n", sz);
211619 jsonDebugPrintBlob(pParse, iStart+n, iStart+n+sz, nIndent+2, pOut);
211624 sqlite3_str_appendall(pOut, "ERROR: unknown node type\n");
211631 sqlite3_str_append(pOut, "\n", 1);
211634 sqlite3_str_appendall(pOut, ": \"");
211638 sqlite3_str_append(pOut, (char*)&c, 1);
211640 sqlite3_str_append(pOut, "\"\n", 2);
212376 x.pOut = &s;
217214 sqlite3_str *pOut;
217229 pOut = sqlite3_str_new(0);
217235 if( ii>0 ) sqlite3_str_append(pOut, " ", 1);
217236 sqlite3_str_appendf(pOut, "{%lld", cell.iRowid);
217239 sqlite3_str_appendf(pOut, " %g", (double)cell.aCoord[jj].f);
217241 sqlite3_str_appendf(pOut, " %d", cell.aCoord[jj].i);
217244 sqlite3_str_append(pOut, "}", 1);
217246 errCode = sqlite3_str_errcode(pOut);
217248 sqlite3_result_text(ctx, sqlite3_str_finish(pOut), -1, sqlite3_free);
218023 GeoPoly *pOut;
218026 pOut = sqlite3_malloc64( GEOPOLY_SZ((sqlite3_int64)s.nVertex) );
218028 if( pOut==0 ) goto parse_json_err;
218029 pOut->nVertex = s.nVertex;
218030 memcpy(pOut->a, s.a, s.nVertex*2*sizeof(GeoCoord));
218031 pOut->hdr[0] = *(unsigned char*)&x;
218032 pOut->hdr[1] = (s.nVertex>>16)&0xff;
218033 pOut->hdr[2] = (s.nVertex>>8)&0xff;
218034 pOut->hdr[3] = s.nVertex&0xff;
218037 return pOut;
218395 GeoPoly *pOut = 0;
218423 pOut = sqlite3_realloc64(p, GEOPOLY_SZ(4));
218424 if( pOut==0 ){
218430 pOut->nVertex = 4;
218432 pOut->hdr[0] = *(unsigned char*)ⅈ
218433 pOut->hdr[1] = 0;
218434 pOut->hdr[2] = 0;
218435 pOut->hdr[3] = 4;
218436 GeoX(pOut,0) = mnX;
218437 GeoY(pOut,0) = mnY;
218438 GeoX(pOut,1) = mxX;
218439 GeoY(pOut,1) = mnY;
218440 GeoX(pOut,2) = mxX;
218441 GeoY(pOut,2) = mxY;
218442 GeoX(pOut,3) = mnX;
218443 GeoY(pOut,3) = mxY;
218454 return pOut;
231174 int (*xOutput)(void *pOut, const void *pData, int nData),
231175 void *pOut, /* First argument for xOutput */
231260 rc = xOutput(pOut, (void*)buf.aBuf, buf.nBuf);
231281 rc = xOutput(pOut, (void*)buf.aBuf, buf.nBuf);
231318 int (*xOutput)(void *pOut, const void *pData, int nData),
231319 void *pOut
231322 return sessionGenerateChangeset(pSession, 0, xOutput, pOut, 0, 0);
231330 int (*xOutput)(void *pOut, const void *pData, int nData),
231331 void *pOut
231334 return sessionGenerateChangeset(pSession, 1, xOutput, pOut, 0, 0);
232209 int (*xOutput)(void *pOut, const void *pData, int nData),
232210 void *pOut,
232340 rc = xOutput(pOut, sOut.aBuf, sOut.nBuf);
232352 rc = xOutput(pOut, sOut.aBuf, sOut.nBuf);
232388 int (*xOutput)(void *pOut, const void *pData, int nData),
232389 void *pOut
232399 rc = sessionChangesetInvert(&sInput, xOutput, pOut, 0, 0);
233686 u8 *pOut = pNew->aRecord;
233690 *pOut++ = 0;
233692 *pOut++ = 0xFF;
233694 memcpy(pOut, pIn, nIn);
233695 pOut += nIn;
233699 pNew->nRecord = pOut - pNew->aRecord;
233713 u8 *pOut;
233718 pOut = pNew->aRecord = (u8*)&pNew[1];
233724 *pOut++ = 0xFF;
233726 memcpy(pOut, a1, n1);
233727 pOut += n1;
233729 memcpy(pOut, a2, n2);
233730 pOut += n2;
233735 pNew->nRecord = pOut - pNew->aRecord;
233864 SessionBuffer *pOut
233872 pOut->nBuf = 0;
233875 sessionAppendBlob(pOut, aRec, nRec, &rc);
233884 sessionAppendByte(pOut, eType, &rc);
233895 if( SQLITE_OK==sessionBufferGrow(pOut, 8, &rc) ){
233896 sessionPutI64(&pOut->aBuf[pOut->nBuf], iVal);
233897 pOut->nBuf += 8;
233905 sessionAppendVarint(pOut, n, &rc);
233908 sessionAppendBlob(pOut, z, n, &rc);
233911 sessionAppendBlob(pOut, z, n, &rc);
233929 sessionAppendBlob(pOut, aRec, iOff, &rc);
233931 sessionAppendByte(pOut, 0x00, &rc);
233935 sessionAppendBlob(pOut, &aRec[iOff], nRec-iOff, &rc);
233937 sessionAppendByte(pOut, 0x00, &rc);
233941 sessionAppendBlob(pOut, aRec, nRec, &rc);
234146 int (*xOutput)(void *pOut, const void *pData, int nData),
234147 void *pOut,
234171 rc = xOutput(pOut, buf.aBuf, buf.nBuf);
234180 if( buf.nBuf>0 ) rc = xOutput(pOut, buf.aBuf, buf.nBuf);
234307 int (*xOutput)(void *pOut, const void *pData, int nData),
234308 void *pOut
234310 return sessionChangegroupOutput(pGrp, xOutput, pOut, 0, 0);
234362 int (*xOutput)(void *pOut, const void *pData, int nData),
234363 void *pOut
234376 rc = sqlite3changegroup_output_strm(pGrp, xOutput, pOut);
234406 u8 *pOut = &pBuf->aBuf[pBuf->nBuf];
234411 memcpy(pOut, a2, nn2);
234412 pOut += nn2;
234414 memcpy(pOut, a1, nn1);
234415 pOut += nn1;
234421 pBuf->nBuf = pOut-pBuf->aBuf;
234455 u8 *pOut = &pBuf->aBuf[pBuf->nBuf];
234460 *pOut++ = SQLITE_UPDATE;
234461 *pOut++ = pIter->bIndirect;
234467 memcpy(pOut, a1, n1);
234468 pOut += n1;
234471 memcpy(pOut, a2, n2);
234472 pOut += n2;
234474 *pOut++ = '\0';
234485 memcpy(pOut, a1, n1);
234486 pOut += n1;
234488 *pOut++ = '\0';
234493 pBuf->nBuf = (pOut - pBuf->aBuf);
234516 int (*xOutput)(void *pOut, const void *pData, int nData),
234517 void *pOut, /* Context for xOutput callback */
234616 rc = xOutput(pOut, sOut.aBuf, sOut.nBuf);
234630 rc = xOutput(pOut, sOut.aBuf, sOut.nBuf);
234702 int (*xOutput)(void *pOut, const void *pData, int nData),
234703 void *pOut
234709 rc = sessionRebase(p, pIter, xOutput, pOut, 0, 0);
241108 Fts5Buffer *pOut; /* Output poslist */
241164 a[i].pOut = pPoslist;
241194 if( a[i].pOut->n==0 || iPos!=pWriter->iPrev ){
241195 sqlite3Fts5PoslistWriterAppend(a[i].pOut, pWriter, iPos);
241211 int bRet = a[0].pOut->n>0;
245718 Fts5StructureLevel *pOut = &pStruct->aLevel[iPromote];
245720 if( pOut->nMerge==0 ){
245729 memcpy(pOut->aSeg, &pLvl->aSeg[is], sizeof(Fts5StructureSegment));
245730 pOut->nSeg++;
250668 Fts5TokenDataMap *pOut = &aOut[i1+i2];
250673 memcpy(pOut, &a1[i1], sizeof(Fts5TokenDataMap));
250676 memcpy(pOut, &a2[i2], sizeof(Fts5TokenDataMap));