Lines Matching refs:pCtx
3749 void *pCtx
10774 void *pCtx, /* Copy of third arg to preupdate_hook() */
11535 void *pCtx, /* Copy of third arg to _filter_table() */
11538 void *pCtx /* First argument passed to xFilter */
12565 void *pCtx, /* Copy of sixth arg to _apply() */
12569 void *pCtx, /* Copy of sixth arg to _apply() */
12573 void *pCtx /* First argument passed to xConflict */
12580 void *pCtx, /* Copy of sixth arg to _apply() */
12584 void *pCtx, /* Copy of sixth arg to _apply() */
12588 void *pCtx, /* First argument passed to xConflict */
12984 void *pCtx, /* Copy of sixth arg to _apply() */
12988 void *pCtx, /* Copy of sixth arg to _apply() */
12992 void *pCtx /* First argument passed to xConflict */
12999 void *pCtx, /* Copy of sixth arg to _apply() */
13003 void *pCtx, /* Copy of sixth arg to _apply() */
13007 void *pCtx, /* First argument passed to xConflict */
13155 sqlite3_context *pCtx, /* Context for returning result/error */
13430 void *pCtx, /* Context passed to xToken() */
13666 void *pCtx,
13670 void *pCtx, /* Copy of 2nd argument to xTokenize() */
16500 sqlite3_context *pCtx; /* Used when p4type is P4_FUNCCTX */ member
24822 sqlite3_context *pCtx /* Write error here if one occurs */ in toLocaltime() argument
24852 sqlite3_result_error(pCtx, "local time unavailable", -1); in toLocaltime()
24943 sqlite3_context *pCtx, /* Function context */ in parseModifier() argument
25022 if( sqlite3_stricmp(z, "localtime")==0 && sqlite3NotPureFunc(pCtx) ){ in parseModifier()
25023 rc = p->isLocal ? SQLITE_OK : toLocaltime(p, pCtx); in parseModifier()
25049 else if( sqlite3_stricmp(z, "utc")==0 && sqlite3NotPureFunc(pCtx) ){ in parseModifier()
25065 rc = toLocaltime(&new, pCtx); in parseModifier()
32218 SQLITE_PRIVATE void sqlite3ResultStrAccum(sqlite3_context *pCtx, StrAccum *p){ in sqlite3ResultStrAccum() argument
32220 sqlite3_result_error_code(pCtx, p->accError); in sqlite3ResultStrAccum()
32223 sqlite3_result_text(pCtx, p->zText, p->nChar, SQLITE_DYNAMIC); in sqlite3ResultStrAccum()
32225 sqlite3_result_text(pCtx, "", 0, SQLITE_STATIC); in sqlite3ResultStrAccum()
44253 afpLockingContext *pCtx;
44254 pNew->lockingContext = pCtx = sqlite3_malloc64( sizeof(*pCtx) );
44255 if( pCtx==0 ){
44261 pCtx->dbPath = zFilename;
44262 pCtx->reserved = 0;
45716 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
45717 unixFile *conchFile = pCtx->conchFile;
45720 char *cPath = pCtx->conchFilePath;
45776 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
45777 unixFile *conchFile = pCtx->conchFile;
45854 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
45856 if( pCtx->conchHeld!=0 ){
45859 unixFile *conchFile = pCtx->conchFile;
45873 (pCtx->lockProxyPath ? pCtx->lockProxyPath : ":auto:"),
45909 if( !pCtx->lockProxyPath ){
45927 && !strncmp(pCtx->lockProxyPath, &readBuf[PROXY_PATHINDEX],
45942 if( !pCtx->lockProxyPath ){
45943 proxyGetLockPath(pCtx->dbPath, lockPath, MAXPATHLEN);
45970 if( pCtx->lockProxyPath!=NULL ){
45971 strlcpy(&writeBuffer[PROXY_PATHINDEX], pCtx->lockProxyPath,
46021 fd = robust_open(pCtx->dbPath, pFile->openFlags, 0);
46030 if( rc==SQLITE_OK && !pCtx->lockProxy ){
46031 char *path = tempLockPath ? tempLockPath : pCtx->lockProxyPath;
46032 rc = proxyCreateUnixFile(path, &pCtx->lockProxy, 1);
46047 pCtx->lockProxyPath = sqlite3DbStrDup(0, tempLockPath);
46048 if( !pCtx->lockProxyPath ){
46054 pCtx->conchHeld = 1;
46056 if( pCtx->lockProxy->pMethod == &afpIoMethods ){
46058 afpCtx = (afpLockingContext *)pCtx->lockProxy->lockingContext;
46059 afpCtx->dbPath = pCtx->lockProxyPath;
46077 proxyLockingContext *pCtx; /* The locking context for the proxy lock */
46080 pCtx = (proxyLockingContext *)pFile->lockingContext;
46081 conchFile = pCtx->conchFile;
46083 (pCtx->lockProxyPath ? pCtx->lockProxyPath : ":auto:"),
46085 if( pCtx->conchHeld>0 ){
46088 pCtx->conchHeld = 0;
46143 proxyLockingContext *pCtx = (proxyLockingContext*)pFile->lockingContext;
46144 char *oldPath = pCtx->lockProxyPath;
46156 unixFile *lockProxy = pCtx->lockProxy;
46157 pCtx->lockProxy=NULL;
46158 pCtx->conchHeld = 0;
46165 pCtx->lockProxyPath = sqlite3DbStrDup(0, path);
46210 proxyLockingContext *pCtx;
46228 pCtx = sqlite3_malloc64( sizeof(*pCtx) );
46229 if( pCtx==0 ){
46232 memset(pCtx, 0, sizeof(*pCtx));
46234 rc = proxyCreateConchPathname(dbPath, &pCtx->conchFilePath);
46236 rc = proxyCreateUnixFile(pCtx->conchFilePath, &pCtx->conchFile, 0);
46247 if( osStat(pCtx->conchFilePath, &conchInfo) == -1 ) {
46254 pCtx->conchHeld = -1; /* read only FS/ lockless */
46260 pCtx->lockProxyPath = sqlite3DbStrDup(0, lockPath);
46264 pCtx->dbPath = sqlite3DbStrDup(0, dbPath);
46265 if( pCtx->dbPath==NULL ){
46273 pCtx->oldLockingContext = pFile->lockingContext;
46274 pFile->lockingContext = pCtx;
46275 pCtx->pOldMethod = pFile->pMethod;
46278 if( pCtx->conchFile ){
46279 pCtx->conchFile->pMethod->xClose((sqlite3_file *)pCtx->conchFile);
46280 sqlite3_free(pCtx->conchFile);
46282 sqlite3DbFree(0, pCtx->lockProxyPath);
46283 sqlite3_free(pCtx->conchFilePath);
46284 sqlite3_free(pCtx);
46301 proxyLockingContext *pCtx = (proxyLockingContext*)pFile->lockingContext;
46303 if( pCtx->lockProxyPath ){
46304 *(const char **)pArg = pCtx->lockProxyPath;
46331 proxyLockingContext *pCtx =
46334 || (pCtx->lockProxyPath &&
46335 !strncmp(pCtx->lockProxyPath, proxyPath, MAXPATHLEN))
46373 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
46374 if( pCtx->conchHeld>0 ){
46375 unixFile *proxy = pCtx->lockProxy;
46412 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
46413 if( pCtx->conchHeld>0 ){
46414 unixFile *proxy = pCtx->lockProxy;
46436 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
46437 if( pCtx->conchHeld>0 ){
46438 unixFile *proxy = pCtx->lockProxy;
46454 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
46455 unixFile *lockProxy = pCtx->lockProxy;
46456 unixFile *conchFile = pCtx->conchFile;
46465 pCtx->lockProxy = 0;
46468 if( pCtx->conchHeld ){
46476 sqlite3DbFree(0, pCtx->lockProxyPath);
46477 sqlite3_free(pCtx->conchFilePath);
46478 sqlite3DbFree(0, pCtx->dbPath);
46480 pFile->lockingContext = pCtx->oldLockingContext;
46481 pFile->pMethod = pCtx->pOldMethod;
46482 sqlite3_free(pCtx);
60209 static int pagerUndoCallback(void *pCtx, Pgno iPg){
60211 Pager *pPager = (Pager *)pCtx;
84284 struct ValueNewStat4Ctx *pCtx /* Second argument for valueNew() */
84295 assert( pCtx!=0 );
84324 pVal = valueNew(db, pCtx);
84337 sqlite3ErrorMsg(pCtx->pParse, "%s", sqlite3_value_text(pVal));
84344 pCtx->pParse->nErr++;
84351 pCtx->pParse->rc = rc;
84383 struct ValueNewStat4Ctx *pCtx /* Second argument for valueNew() */
84400 assert( (pExpr->flags & EP_TokenOnly)==0 || pCtx==0 );
84406 rc = valueFromExpr(db, pExpr->pLeft, enc, aff, ppVal, pCtx);
84440 pVal = valueNew(db, pCtx);
84479 if( SQLITE_OK==valueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal,pCtx)
84498 pVal = valueNew(db, pCtx);
84508 pVal = valueNew(db, pCtx);
84518 else if( op==TK_FUNCTION && pCtx!=0 ){
84519 rc = valueFromFunction(db, pExpr, enc, affinity, &pVal, pCtx);
84524 pVal = valueNew(db, pCtx);
84537 if( pCtx==0 || NEVER(pCtx->pParse->nErr==0) )
84543 if( pCtx==0 ) sqlite3ValueFree(pVal);
84545 assert( pCtx==0 ); sqlite3ValueFree(pVal);
85287 sqlite3_context *pCtx;
85289 nByte = sizeof(*pCtx) + (nArg-1)*sizeof(sqlite3_value*);
85290 pCtx = sqlite3DbMallocRawNN(pParse->db, nByte);
85291 if( pCtx==0 ){
85296 pCtx->pOut = 0;
85297 pCtx->pFunc = (FuncDef*)pFunc;
85298 pCtx->pVdbe = 0;
85299 pCtx->isError = 0;
85300 pCtx->argc = nArg;
85301 pCtx->iOp = sqlite3VdbeCurrentAddr(v);
85303 p1, p2, p3, (char*)pCtx, P4_FUNCCTX);
86616 sqlite3_context *pCtx = pOp->p4.pCtx;
86617 if( pOp->p4type!=P4_FUNCCTX || pCtx->argc==1 ){
86619 }else if( pCtx->argc>1 ){
86620 sqlite3_str_appendf(&x, "%d..%d", v1, v1+pCtx->argc-1);
86774 FuncDef *pDef = pOp->p4.pCtx->pFunc;
90215 SQLITE_PRIVATE int sqlite3NotPureFunc(sqlite3_context *pCtx){
90218 if( pCtx->pVdbe==0 ) return 1;
90220 pOp = pCtx->pVdbe->aOp + pCtx->iOp;
90232 pCtx->pFunc->zName, zContext);
90233 sqlite3_result_error(pCtx, zMsg, -1);
90765 sqlite3_context *pCtx, /* Function context */
90771 Mem *pOut = pCtx->pOut;
90775 sqlite3_result_error_toobig(pCtx);
90780 sqlite3_result_error_nomem(pCtx);
90784 sqlite3VdbeChangeEncoding(pOut, pCtx->enc);
90786 sqlite3_result_error_toobig(pCtx);
90792 sqlite3_context *pCtx /* Set a SQLITE_TOOBIG error if not NULL */
90803 if( pCtx!=0 ){
90804 sqlite3_result_error_toobig(pCtx);
90807 assert( pCtx!=0 );
90808 sqlite3_result_error_toobig(pCtx);
90813 sqlite3_context *pCtx,
90819 if( pCtx==0 || n<0 ){
90820 invokeValueDestructor(z, xDel, pCtx);
90825 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90826 setResultStrOrError(pCtx, z, n, 0, xDel);
90829 sqlite3_context *pCtx,
90836 if( pCtx==0 ){
90841 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90843 (void)invokeValueDestructor(z, xDel, pCtx);
90845 setResultStrOrError(pCtx, z, (int)n, 0, xDel);
90848 SQLITE_API void sqlite3_result_double(sqlite3_context *pCtx, double rVal){
90850 if( pCtx==0 ) return;
90852 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90853 sqlite3VdbeMemSetDouble(pCtx->pOut, rVal);
90855 SQLITE_API void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){
90857 if( pCtx==0 ) return;
90859 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90860 pCtx->isError = SQLITE_ERROR;
90861 sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);
90864 SQLITE_API void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){
90866 if( pCtx==0 ) return;
90868 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90869 pCtx->isError = SQLITE_ERROR;
90870 sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);
90873 SQLITE_API void sqlite3_result_int(sqlite3_context *pCtx, int iVal){
90875 if( pCtx==0 ) return;
90877 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90878 sqlite3VdbeMemSetInt64(pCtx->pOut, (i64)iVal);
90880 SQLITE_API void sqlite3_result_int64(sqlite3_context *pCtx, i64 iVal){
90882 if( pCtx==0 ) return;
90884 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90885 sqlite3VdbeMemSetInt64(pCtx->pOut, iVal);
90887 SQLITE_API void sqlite3_result_null(sqlite3_context *pCtx){
90889 if( pCtx==0 ) return;
90891 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90892 sqlite3VdbeMemSetNull(pCtx->pOut);
90895 sqlite3_context *pCtx,
90902 if( pCtx==0 ){
90907 pOut = pCtx->pOut;
90913 SQLITE_API void sqlite3_result_subtype(sqlite3_context *pCtx, unsigned int eSubtype){
90916 if( pCtx==0 ) return;
90919 if( pCtx->pFunc!=0
90920 && (pCtx->pFunc->funcFlags & SQLITE_RESULT_SUBTYPE)==0
90925 pCtx->pFunc->zName);
90926 sqlite3_result_error(pCtx, zErr, -1);
90930 pOut = pCtx->pOut;
90936 sqlite3_context *pCtx,
90942 if( pCtx==0 ){
90947 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90948 setResultStrOrError(pCtx, z, n, SQLITE_UTF8, xDel);
90951 sqlite3_context *pCtx,
90958 if( pCtx==0 ){
90963 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90970 (void)invokeValueDestructor(z, xDel, pCtx);
90972 setResultStrOrError(pCtx, z, (int)n, enc, xDel);
90973 sqlite3VdbeMemZeroTerminateIfAble(pCtx->pOut);
90978 sqlite3_context *pCtx,
90983 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90984 setResultStrOrError(pCtx, z, n & ~(u64)1, SQLITE_UTF16NATIVE, xDel);
90987 sqlite3_context *pCtx,
90992 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
90993 setResultStrOrError(pCtx, z, n & ~(u64)1, SQLITE_UTF16BE, xDel);
90996 sqlite3_context *pCtx,
91001 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
91002 setResultStrOrError(pCtx, z, n & ~(u64)1, SQLITE_UTF16LE, xDel);
91005 SQLITE_API void sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){
91009 if( pCtx==0 ) return;
91011 sqlite3_result_null(pCtx);
91015 pOut = pCtx->pOut;
91016 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
91018 sqlite3VdbeChangeEncoding(pOut, pCtx->enc);
91020 sqlite3_result_error_toobig(pCtx);
91023 SQLITE_API void sqlite3_result_zeroblob(sqlite3_context *pCtx, int n){
91024 sqlite3_result_zeroblob64(pCtx, n>0 ? n : 0);
91026 SQLITE_API int sqlite3_result_zeroblob64(sqlite3_context *pCtx, u64 n){
91030 if( pCtx==0 ) return SQLITE_MISUSE_BKPT;
91032 pOut = pCtx->pOut;
91035 sqlite3_result_error_toobig(pCtx);
91039 sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n);
91042 return sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n);
91045 SQLITE_API void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){
91047 if( pCtx==0 ) return;
91049 pCtx->isError = errCode ? errCode : -1;
91051 if( pCtx->pVdbe ) pCtx->pVdbe->rcApp = errCode;
91053 if( pCtx->pOut->flags & MEM_Null ){
91054 setResultStrOrError(pCtx, sqlite3ErrStr(errCode), -1, SQLITE_UTF8,
91060 SQLITE_API void sqlite3_result_error_toobig(sqlite3_context *pCtx){
91062 if( pCtx==0 ) return;
91064 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
91065 pCtx->isError = SQLITE_TOOBIG;
91066 sqlite3VdbeMemSetStr(pCtx->pOut, "string or blob too big", -1,
91071 SQLITE_API void sqlite3_result_error_nomem(sqlite3_context *pCtx){
91073 if( pCtx==0 ) return;
91075 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
91076 sqlite3VdbeMemSetNull(pCtx->pOut);
91077 pCtx->isError = SQLITE_NOMEM_BKPT;
91078 sqlite3OomFault(pCtx->pOut->db);
91086 SQLITE_PRIVATE void sqlite3ResultIntReal(sqlite3_context *pCtx){
91087 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
91088 if( pCtx->pOut->flags & MEM_Int ){
91089 pCtx->pOut->flags &= ~MEM_Int;
91090 pCtx->pOut->flags |= MEM_IntReal;
91528 SQLITE_API void *sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){
91532 if( pCtx==0 ) return 0;
91534 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
91536 if( pCtx->pVdbe==0 ) return 0;
91538 assert( pCtx->pVdbe!=0 );
91540 for(pAuxData=pCtx->pVdbe->pAuxData; pAuxData; pAuxData=pAuxData->pNextAux){
91541 if( pAuxData->iAuxArg==iArg && (pAuxData->iAuxOp==pCtx->iOp || iArg<0) ){
91560 sqlite3_context *pCtx,
91569 if( pCtx==0 ) return;
91571 pVdbe= pCtx->pVdbe;
91572 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
91580 if( pAuxData->iAuxArg==iArg && (pAuxData->iAuxOp==pCtx->iOp || iArg<0) ){
91587 pAuxData->iAuxOp = pCtx->iOp;
91591 if( pCtx->isError==0 ) pCtx->isError = -1;
100773 sqlite3_context *pCtx;
100780 pCtx = sqlite3DbMallocRawNN(db, n*sizeof(sqlite3_value*) +
100781 (sizeof(pCtx[0]) + sizeof(Mem) - sizeof(sqlite3_value*)));
100782 if( pCtx==0 ) goto no_mem;
100783 pCtx->pMem = 0;
100784 pCtx->pOut = (Mem*)&(pCtx->argv[n]);
100785 sqlite3VdbeMemInit(pCtx->pOut, db, MEM_Null);
100786 pCtx->pFunc = pOp->p4.pFunc;
100787 pCtx->iOp = (int)(pOp - aOp);
100788 pCtx->pVdbe = p;
100789 pCtx->skipFlag = 0;
100790 pCtx->isError = 0;
100791 pCtx->enc = encoding;
100792 pCtx->argc = n;
100794 pOp->p4.pCtx = pCtx;
100805 sqlite3_context *pCtx;
100809 pCtx = pOp->p4.pCtx;
100827 if( pCtx->pMem != pMem ){
100828 pCtx->pMem = pMem;
100829 for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i];
100833 for(i=0; i<pCtx->argc; i++){
100834 assert( memIsValid(pCtx->argv[i]) );
100835 REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]);
100840 assert( pCtx->pOut->flags==MEM_Null );
100841 assert( pCtx->isError==0 );
100842 assert( pCtx->skipFlag==0 );
100845 (pCtx->pFunc->xInverse)(pCtx,pCtx->argc,pCtx->argv);
100848 (pCtx->pFunc->xSFunc)(pCtx,pCtx->argc,pCtx->argv); /* IMP: R-24505-23230 */
100850 if( pCtx->isError ){
100851 if( pCtx->isError>0 ){
100852 sqlite3VdbeError(p, "%s", sqlite3_value_text(pCtx->pOut));
100853 rc = pCtx->isError;
100855 if( pCtx->skipFlag ){
100859 pCtx->skipFlag = 0;
100861 sqlite3VdbeMemRelease(pCtx->pOut);
100862 pCtx->pOut->flags = MEM_Null;
100863 pCtx->isError = 0;
100866 assert( pCtx->pOut->flags==MEM_Null );
100867 assert( pCtx->skipFlag==0 );
101764 sqlite3_context *pCtx;
101767 pCtx = pOp->p4.pCtx;
101774 if( pCtx->pOut != pOut ){
101775 pCtx->pVdbe = p;
101776 pCtx->pOut = pOut;
101777 pCtx->enc = encoding;
101778 for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i];
101780 assert( pCtx->pVdbe==p );
101784 for(i=0; i<pCtx->argc; i++){
101785 assert( memIsValid(pCtx->argv[i]) );
101786 REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]);
101790 assert( pCtx->isError==0 );
101791 (*pCtx->pFunc->xSFunc)(pCtx, pCtx->argc, pCtx->argv);/* IMP: R-24505-23230 */
101794 if( pCtx->isError ){
101795 if( pCtx->isError>0 ){
101797 rc = pCtx->isError;
101799 sqlite3VdbeDeleteAuxData(db, &p->pAuxData, pCtx->iOp, pOp->p1);
101800 pCtx->isError = 0;
104484 static void *vdbeSorterFlushThread(void *pCtx){
104485 SortSubtask *pTask = (SortSubtask*)pCtx;
104536 void *pCtx;
104544 pCtx = (void*)pTask;
104557 rc = vdbeSorterCreateThread(pTask, vdbeSorterFlushThread, pCtx);
104722 static void *vdbeIncrPopulateThread(void *pCtx){
104723 IncrMerger *pIncr = (IncrMerger*)pCtx;
105058 static void *vdbePmaReaderBgIncrInit(void *pCtx){
105059 PmaReader *pReader = (PmaReader*)pCtx;
105086 void *pCtx = (void*)pReadr;
105087 rc = vdbeSorterCreateThread(pIncr->pTask, vdbePmaReaderBgIncrInit, pCtx);
117110 struct RenameCtx *pCtx,
117120 if( pCtx ){
117122 pToken->pNext = pCtx->pList;
117123 pCtx->pList = pToken;
117124 pCtx->nList++;
117182 static RenameToken *renameColumnTokenNext(RenameCtx *pCtx){
117183 RenameToken *pBest = pCtx->pList;
117190 for(pp=&pCtx->pList; *pp!=pBest; pp=&(*pp)->pNext);
117204 sqlite3_context *pCtx,
117218 sqlite3_result_error(pCtx, zErr, -1);
117230 RenameCtx *pCtx,
117242 renameTokenFind(pParse, pCtx, (const void*)zName);
117255 RenameCtx *pCtx,
117264 renameTokenFind(pParse, pCtx, (const void*)zName);
117329 sqlite3_context *pCtx, /* Return result here */
117337 sqlite3 *db = sqlite3_context_db_handle(pCtx);
117419 sqlite3_result_text(pCtx, zOut, -1, SQLITE_TRANSIENT);
129949 sqlite3_context *pCtx,
129970 p = pBlob = contextMalloc(pCtx, (nHex/2)+1);
129993 sqlite3_result_blob(pCtx, pBlob, (p - pBlob), sqlite3_free);
155963 VtabCtx *pCtx;
155969 for(pCtx=db->pVtabCtx; pCtx; pCtx=pCtx->pPrior){
155970 if( pCtx->pTab==pTab ){
156203 VtabCtx *pCtx;
156233 pCtx = db->pVtabCtx;
156234 if( !pCtx || pCtx->bDeclared ){
156240 pTab = pCtx->pTab;
156270 && pCtx->pVTable->pMod->pModule->xUpdate!=0
156285 pCtx->bDeclared = 1;
169495 sqlite3_context *pCtx,
169499 i64 *p = (i64*)sqlite3_aggregate_context(pCtx, sizeof(*p));
169504 static void row_numberValueFunc(sqlite3_context *pCtx){
169505 i64 *p = (i64*)sqlite3_aggregate_context(pCtx, sizeof(*p));
169506 sqlite3_result_int64(pCtx, (p ? *p : 0));
169526 sqlite3_context *pCtx,
169531 p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
169536 static void dense_rankValueFunc(sqlite3_context *pCtx){
169538 p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
169544 sqlite3_result_int64(pCtx, p->nValue);
169558 sqlite3_context *pCtx,
169563 p = (struct NthValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
169585 sqlite3_result_error_nomem(pCtx);
169595 pCtx, "second argument to nth_value must be a positive integer", -1
169598 static void nth_valueFinalizeFunc(sqlite3_context *pCtx){
169600 p = (struct NthValueCtx*)sqlite3_aggregate_context(pCtx, 0);
169602 sqlite3_result_value(pCtx, p->pValue);
169611 sqlite3_context *pCtx,
169616 p = (struct NthValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
169620 sqlite3_result_error_nomem(pCtx);
169626 static void first_valueFinalizeFunc(sqlite3_context *pCtx){
169628 p = (struct NthValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
169630 sqlite3_result_value(pCtx, p->pValue);
169645 sqlite3_context *pCtx,
169650 p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
169660 static void rankValueFunc(sqlite3_context *pCtx){
169662 p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
169664 sqlite3_result_int64(pCtx, p->nValue);
169676 sqlite3_context *pCtx,
169683 p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
169689 sqlite3_context *pCtx,
169696 p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
169699 static void percent_rankValueFunc(sqlite3_context *pCtx){
169701 p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
169706 sqlite3_result_double(pCtx, r);
169708 sqlite3_result_double(pCtx, 0.0);
169721 sqlite3_context *pCtx,
169728 p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
169734 sqlite3_context *pCtx,
169741 p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
169744 static void cume_distValueFunc(sqlite3_context *pCtx){
169746 p = (struct CallCount*)sqlite3_aggregate_context(pCtx, 0);
169749 sqlite3_result_double(pCtx, r);
169770 sqlite3_context *pCtx,
169776 p = (struct NtileCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
169782 pCtx, "argument of ntile must be a positive integer", -1
169790 sqlite3_context *pCtx,
169797 p = (struct NtileCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
169800 static void ntileValueFunc(sqlite3_context *pCtx){
169802 p = (struct NtileCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
169806 sqlite3_result_int64(pCtx, p->iRow+1);
169815 sqlite3_result_int64(pCtx, 1 + iRow/(nSize+1));
169817 sqlite3_result_int64(pCtx, 1 + nLarge + (iRow-iSmall)/nSize);
169836 sqlite3_context *pCtx,
169842 p = (struct LastValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
169847 sqlite3_result_error_nomem(pCtx);
169854 sqlite3_context *pCtx,
169861 p = (struct LastValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
169870 static void last_valueValueFunc(sqlite3_context *pCtx){
169872 p = (struct LastValueCtx*)sqlite3_aggregate_context(pCtx, 0);
169874 sqlite3_result_value(pCtx, p->pVal);
169877 static void last_valueFinalizeFunc(sqlite3_context *pCtx){
169879 p = (struct LastValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
169881 sqlite3_result_value(pCtx, p->pVal);
182545 void* pCtx,
182605 pColl->pUser = pCtx;
183428 void* pCtx,
183431 return sqlite3_create_collation_v2(db, zName, enc, pCtx, xCompare, 0);
183441 void* pCtx,
183452 rc = createCollation(db, zName, (u8)enc, pCtx, xCompare, xDel);
183466 void* pCtx,
183479 rc = createCollation(db, zName8, (u8)enc, pCtx, xCompare, 0);
184318 sqlite3_context *pCtx = va_arg(ap, sqlite3_context*);
184319 sqlite3ResultIntReal(pCtx);
189604 sqlite3_context *pCtx, /* Context for sqlite3_result_xxx() calls */
189617 sqlite3_result_pointer(pCtx, pCsr, "fts3cursor", 0);
189622 sqlite3_result_int64(pCtx, pCsr->iPrevId);
189627 sqlite3_result_int64(pCtx, pCsr->iLangid);
189630 sqlite3_result_int(pCtx, 0);
189642 sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1));
191979 static int fts3AllocateMSI(Fts3Expr *pExpr, int iPhrase, void *pCtx){
191980 Fts3Table *pTab = (Fts3Table*)pCtx;
192813 sqlite3_context *pCtx, /* Context for sqlite3_result_xxx() calls */
192821 sqlite3_result_text(pCtx, p->csr.zTerm, p->csr.nTerm, SQLITE_TRANSIENT);
192826 sqlite3_result_int(pCtx, p->iCol-1);
192828 sqlite3_result_text(pCtx, "*", -1, SQLITE_STATIC);
192833 sqlite3_result_int64(pCtx, p->aStat[p->iCol].nDoc);
192837 sqlite3_result_int64(pCtx, p->aStat[p->iCol].nOcc);
192842 sqlite3_result_int(pCtx, p->iLangid);
193003 sqlite3_context *pCtx; /* Write error message here */
196389 sqlite3_context *pCtx, /* Context for sqlite3_result_xxx() calls */
196397 sqlite3_result_text(pCtx, pCsr->zInput, -1, SQLITE_TRANSIENT);
196400 sqlite3_result_text(pCtx, pCsr->zToken, pCsr->nToken, SQLITE_TRANSIENT);
196403 sqlite3_result_int(pCtx, pCsr->iStart);
196406 sqlite3_result_int(pCtx, pCsr->iEnd);
196410 sqlite3_result_int(pCtx, pCsr->iPos);
202561 void *pCtx /* Second argument to pass to callback */
202568 rc = fts3ExprIterate2(pExpr->pLeft, piPhrase, x, pCtx);
202570 rc = fts3ExprIterate2(pExpr->pRight, piPhrase, x, pCtx);
202573 rc = x(pExpr, *piPhrase, pCtx);
202592 void *pCtx /* Second argument to pass to callback */
202595 return fts3ExprIterate2(pExpr, &iPhrase, x, pCtx);
203259 void *pCtx /* Pointer to MatchInfo structure */
203261 MatchInfo *p = (MatchInfo *)pCtx;
203275 void *pCtx /* Pointer to MatchInfo structure */
203278 MatchInfo *p = (MatchInfo *)pCtx;
203410 void *pCtx /* Pointer to MatchInfo structure */
203412 LcsIterator *aIter = (LcsIterator *)pCtx;
203663 sqlite3_context *pCtx, /* Return results here */
203704 sqlite3_result_error(pCtx, zErr, -1);
203736 sqlite3_result_error_code(pCtx, rc);
203740 sqlite3_result_blob(pCtx, aOut, n, xDestroyOut);
203748 sqlite3_context *pCtx, /* SQLite function call context */
203774 sqlite3_result_text(pCtx, "", 0, SQLITE_STATIC);
203842 sqlite3_result_error_code(pCtx, rc);
203845 sqlite3_result_text(pCtx, res.z, -1, sqlite3_free);
203900 sqlite3_context *pCtx, /* SQLite function call context */
203912 sqlite3_result_text(pCtx, "", 0, SQLITE_STATIC);
204028 sqlite3_result_error_code(pCtx, rc);
204031 sqlite3_result_text(pCtx, res.z, res.n-1, sqlite3_free);
205103 sqlite3_context *pCtx; /* Function context - put error messages here */
205337 static void jsonStringInit(JsonString *p, sqlite3_context *pCtx){
205338 p->pCtx = pCtx;
205355 if( p->pCtx ) sqlite3_result_error_nomem(p->pCtx);
205625 sqlite3_result_error(p->pCtx, "JSON cannot hold BLOB values", -1);
205649 assert( ctx==0 || ctx==p->pCtx );
205651 int flags = SQLITE_PTR_TO_INT(sqlite3_user_data(p->pCtx));
205655 sqlite3_result_text64(p->pCtx, p->zBuf, p->nUsed,
205670 sqlite3_result_text64(p->pCtx, sqlite3RCStrRef(p->zBuf), p->nUsed,
205674 sqlite3_result_error_nomem(p->pCtx);
205677 sqlite3_result_error_nomem(p->pCtx);
205679 sqlite3_result_error(p->pCtx, "malformed JSON", -1);
205921 sqlite3_context *pCtx,
205926 sqlite3_result_error(pCtx, zMsg, -1);
206835 sqlite3_context *pCtx /* Report errors here */
206852 if( pCtx ) sqlite3_result_error(pCtx, "malformed JSON", -1);
206860 if( pCtx!=0 ){
206862 sqlite3_result_error_nomem(pCtx);
206864 sqlite3_result_error(pCtx, "malformed JSON", -1);
206883 sqlite3_result_error_nomem(pStr->pCtx);
206888 px.db = sqlite3_context_db_handle(pStr->pCtx);
206892 sqlite3_result_error_nomem(pStr->pCtx);
206896 sqlite3_result_blob(pStr->pCtx, px.aBlob, px.nBlob, SQLITE_DYNAMIC);
207883 sqlite3_context *pCtx, /* Return value for this function */
207888 sqlite3 *db = sqlite3_context_db_handle(pCtx);
207892 sqlite3_result_error(pCtx, "malformed JSON", -1);
207898 sqlite3_result_null(pCtx);
207903 sqlite3_result_int(pCtx, 1);
207908 sqlite3_result_int(pCtx, 0);
207930 sqlite3_result_int64(pCtx, bNeg ? -iRes : iRes);
207932 sqlite3_result_int64(pCtx, SMALLEST_INT64);
207952 sqlite3_result_double(pCtx, r);
207957 sqlite3_result_text(pCtx, (char*)&pParse->aBlob[i+n], sz,
208003 sqlite3_result_text(pCtx, zOut, iOut, SQLITE_DYNAMIC);
208008 int flags = textOnly ? 0 : SQLITE_PTR_TO_INT(sqlite3_user_data(pCtx));
208010 sqlite3_result_blob(pCtx, &pParse->aBlob[i], sz+n, SQLITE_TRANSIENT);
208012 jsonReturnTextJsonFromBlob(pCtx, &pParse->aBlob[i], sz+n);
208023 sqlite3_result_error_nomem(pCtx);
208027 sqlite3_result_error(pCtx, "malformed JSON", -1);
209450 pStr->pCtx = ctx;
209459 pStr->pCtx = ctx;
209566 pStr->pCtx = ctx;
209580 pStr->pCtx = ctx;
214900 sqlite3_context *pCtx, /* Context for error messages */
214906 testcase( pCtx==0 );
214913 if( pCtx ) sqlite3_result_error_nomem(pCtx);
214923 if( pCtx ) sqlite3_result_error_nomem(pCtx);
216683 sqlite3_context *pCtx, /* SQLite scalar function context */
216690 sqlite3_result_error(pCtx, zBuf, -1);
217046 static void icuCollationDel(void *pCtx){
217047 UCollator *p = (UCollator *)pCtx;
217056 void *pCtx,
217063 UCollator *p = (UCollator *)pCtx;
219065 sqlite3_context *pCtx,
219069 sqlite3rbu *p = sqlite3_user_data(pCtx);
219078 sqlite3_result_text(pCtx, zIn, -1, SQLITE_STATIC);
219085 sqlite3_result_text(pCtx, &zIn[i+1], -1, SQLITE_STATIC);
220309 sqlite3_context *pCtx,
220313 sqlite3rbu *p = sqlite3_user_data(pCtx);
220334 sqlite3_result_error_code(pCtx, rc);
222016 sqlite3_context *pCtx,
222020 sqlite3rbu *p = (sqlite3rbu*)sqlite3_user_data(pCtx);
222033 sqlite3_result_error(pCtx, zErrmsg, -1);
222041 sqlite3_result_int(pCtx, nIndex);
222043 sqlite3_result_error(pCtx, sqlite3_errmsg(db), -1);
224919 void *pCtx;
224939 int (*xTableFilter)(void *pCtx, const char *zTab);
225431 assert( pTab->nCol-1==pSession->hook.xCount(pSession->hook.pCtx) );
225435 assert( pTab->nCol==pSession->hook.xCount(pSession->hook.pCtx) );
225443 rc = pSession->hook.xNew(pSession->hook.pCtx, i, &pVal);
225445 rc = pSession->hook.xOld(pSession->hook.pCtx, i, &pVal);
225790 rc = pSession->hook.xNew(pSession->hook.pCtx, iCol, &pVal);
225793 rc = pSession->hook.xOld(pSession->hook.pCtx, iCol, &pVal);
226421 static int sessionStat1Old(void *pCtx, int iCol, sqlite3_value **ppVal){
226422 SessionStat1Ctx *p = (SessionStat1Ctx*)pCtx;
226424 int rc = p->hook.xOld(p->hook.pCtx, iCol, &pVal);
226431 static int sessionStat1New(void *pCtx, int iCol, sqlite3_value **ppVal){
226432 SessionStat1Ctx *p = (SessionStat1Ctx*)pCtx;
226434 int rc = p->hook.xNew(p->hook.pCtx, iCol, &pVal);
226441 static int sessionStat1Count(void *pCtx){
226442 SessionStat1Ctx *p = (SessionStat1Ctx*)pCtx;
226443 return p->hook.xCount(p->hook.pCtx);
226445 static int sessionStat1Depth(void *pCtx){
226446 SessionStat1Ctx *p = (SessionStat1Ctx*)pCtx;
226447 return p->hook.xDepth(p->hook.pCtx);
226463 pSession->hook.xNew(pSession->hook.pCtx, ii, &p);
226484 pSession->hook.xNew(pSession->hook.pCtx, ii-pTab->bRowid, &p);
226580 nExpect = pSession->hook.xCount(pSession->hook.pCtx);
226599 pSession->hook.pCtx = (void*)&stat1;
226645 TESTONLY(int trc = ) pSession->hook.xOld(pSession->hook.pCtx, i, &p);
226648 TESTONLY(int trc = ) pSession->hook.xNew(pSession->hook.pCtx, i, &p);
226684 pSession->hook.xOld(pSession->hook.pCtx, i, &p);
226686 pSession->hook.xNew(pSession->hook.pCtx, i, &p);
226692 if( pSession->bIndirect || pSession->hook.xDepth(pSession->hook.pCtx) ){
226704 if( pSession->hook.xDepth(pSession->hook.pCtx)==0
226769 void *pCtx, /* Copy of third arg to preupdate_hook() */
226784 for(pSession=(sqlite3_session *)pCtx; pSession; pSession=pSession->pNext){
226809 static int sessionPreupdateOld(void *pCtx, int iVal, sqlite3_value **ppVal){
226810 return sqlite3_preupdate_old((sqlite3*)pCtx, iVal, ppVal);
226812 static int sessionPreupdateNew(void *pCtx, int iVal, sqlite3_value **ppVal){
226813 return sqlite3_preupdate_new((sqlite3*)pCtx, iVal, ppVal);
226815 static int sessionPreupdateCount(void *pCtx){
226816 return sqlite3_preupdate_count((sqlite3*)pCtx);
226818 static int sessionPreupdateDepth(void *pCtx){
226819 return sqlite3_preupdate_depth((sqlite3*)pCtx);
226829 pSession->hook.pCtx = (void*)pSession->db;
226846 static int sessionDiffOld(void *pCtx, int iVal, sqlite3_value **ppVal){
226847 SessionDiffCtx *p = (SessionDiffCtx*)pCtx;
226851 static int sessionDiffNew(void *pCtx, int iVal, sqlite3_value **ppVal){
226852 SessionDiffCtx *p = (SessionDiffCtx*)pCtx;
226856 static int sessionDiffCount(void *pCtx){
226857 SessionDiffCtx *p = (SessionDiffCtx*)pCtx;
226860 static int sessionDiffDepth(void *pCtx){
226861 (void)pCtx;
226873 pSession->hook.pCtx = (void*)pDiffCtx;
226970 SessionDiffCtx *pDiffCtx = (SessionDiffCtx*)pSession->hook.pCtx;
227034 SessionDiffCtx *pDiffCtx = (SessionDiffCtx*)pSession->hook.pCtx;
227246 void *pCtx /* First argument passed to xFilter */
227249 pSession->pFilterCtx = pCtx;
229645 void *pCtx, /* First argument for conflict handler */
229675 res = xConflict(pCtx, eType, pIter);
229689 res = xConflict(pCtx, eType+1, pIter);
229748 void *pCtx, /* First argument for the conflict handler */
229787 SQLITE_CHANGESET_DATA, p, pIter, xConflict, pCtx, pbRetry
229791 SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, 0
229826 SQLITE_CHANGESET_DATA, p, pIter, xConflict, pCtx, pbRetry
229832 SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, 0
229859 SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, pbReplace
229882 void *pCtx /* First argument passed to xConflict */
229888 rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, &bReplace, &bRetry);
229899 rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, 0, 0);
229920 rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, 0, 0);
229940 void *pCtx /* First argument passed to xConflict */
229964 rc = sessionApplyOneWithRetry(db, pIter2, pApply, xConflict, pCtx);
229994 void *pCtx, /* Copy of sixth arg to _apply() */
229998 void *pCtx, /* Copy of fifth arg to _apply() */
230002 void *pCtx, /* First argument passed to xConflict */
230038 db, pIter->bPatchset, zTab, &sApply, xConflict, pCtx
230063 schemaMismatch = (xFilter && (0==xFilter(pCtx, zNew)));
230130 rc = sessionApplyOneWithRetry(db, pIter, &sApply, xConflict, pCtx);
230141 rc = sessionRetryConstraints(db, bPatchset, zTab, &sApply, xConflict, pCtx);
230152 res = xConflict(pCtx, SQLITE_CHANGESET_FOREIGN_KEY, &sIter);
230195 void *pCtx, /* Copy of sixth arg to _apply() */
230199 void *pCtx, /* Copy of sixth arg to _apply() */
230203 void *pCtx, /* First argument passed to xConflict */
230219 db, pIter, xFilter, xConflict, pCtx, ppRebase, pnRebase, flags
230241 void *pCtx, /* Copy of sixth arg to _apply() */
230245 void *pCtx, /* Copy of fifth arg to _apply() */
230249 void *pCtx /* First argument passed to xConflict */
230252 db, nChangeset, pChangeset, xFilter, xConflict, pCtx, 0, 0, 0
230266 void *pCtx, /* Copy of sixth arg to _apply() */
230270 void *pCtx, /* Copy of sixth arg to _apply() */
230274 void *pCtx, /* First argument passed to xConflict */
230283 db, pIter, xFilter, xConflict, pCtx, ppRebase, pnRebase, flags
230293 void *pCtx, /* Copy of sixth arg to _apply() */
230297 void *pCtx, /* Copy of sixth arg to _apply() */
230301 void *pCtx /* First argument passed to xConflict */
230304 db, xInput, pIn, xFilter, xConflict, pCtx, 0, 0, 0
231464 sqlite3_context *pCtx, /* Context for returning result/error */
231739 void *pCtx, /* Context passed to xToken() */
231975 void *pCtx,
231979 void *pCtx, /* Copy of 2nd argument to xTokenize() */
232303 void *pCtx, /* Context passed to xToken() */
234698 sqlite3_context *pCtx, /* Context for returning result/error */
234708 sqlite3_result_error(pCtx, zErr, -1);
234719 sqlite3_result_text(pCtx, "", -1, SQLITE_STATIC);
234735 sqlite3_result_text(pCtx, (const char*)ctx.zOut, -1, SQLITE_TRANSIENT);
234740 sqlite3_result_error_code(pCtx, rc);
234876 sqlite3_context *pCtx, /* Context for returning result/error */
234898 sqlite3_result_error(pCtx, zErr, -1);
235020 sqlite3_result_text(pCtx, (const char*)ctx.zOut, -1, SQLITE_TRANSIENT);
235022 sqlite3_result_error_code(pCtx, rc);
235139 sqlite3_context *pCtx, /* Context for returning result/error */
235186 sqlite3_result_double(pCtx, -1.0 * score);
235188 sqlite3_result_error_code(pCtx, rc);
236394 void *pCtx, /* Context passed to xToken() */
236399 pConfig->pTok, pCtx, flags, pText, nText, xToken
238398 TokenCtx *pCtx = (TokenCtx*)pContext;
238399 Fts5ExprPhrase *pPhrase = pCtx->pPhrase;
238404 if( pCtx->rc!=SQLITE_OK ) return pCtx->rc;
238417 if( pCtx->pConfig->bTokendata ){
238437 pCtx->pPhrase = pPhrase = pNew;
238447 if( pCtx->pConfig->bTokendata && rc==SQLITE_OK ){
238453 pCtx->rc = rc;
239403 sqlite3_context *pCtx, /* Function call context */
239408 Fts5Global *pGlobal = (Fts5Global*)sqlite3_user_data(pCtx);
239409 sqlite3 *db = sqlite3_context_db_handle(pCtx);
239426 sqlite3_result_error(pCtx, zErr, -1);
239439 sqlite3_result_error_nomem(pCtx);
239469 sqlite3_result_text(pCtx, zText, -1, SQLITE_TRANSIENT);
239476 sqlite3_result_error(pCtx, zErr, -1);
239479 sqlite3_result_error_code(pCtx, rc);
239488 sqlite3_context *pCtx, /* Function call context */
239492 fts5ExprFunction(pCtx, nArg, apVal, 0);
239495 sqlite3_context *pCtx, /* Function call context */
239499 fts5ExprFunction(pCtx, nArg, apVal, 1);
239508 sqlite3_context *pCtx, /* Function call context */
239515 sqlite3_result_error(pCtx,
239525 sqlite3_result_int(pCtx, aArr[sqlite3Fts5UnicodeCategory((u32)iCode)]);
239529 sqlite3_context *pCtx, /* Function call context */
239534 sqlite3_result_error(pCtx,
239542 sqlite3_result_int(pCtx, sqlite3Fts5UnicodeFold(iCode, bRemoveDiacritics));
239564 void *pCtx = (void*)pGlobal;
239568 rc = sqlite3_create_function(db, p->z, -1, SQLITE_UTF8, pCtx, p->x, 0, 0);
239685 void *pCtx, /* Copy of 2nd argument to xTokenize() */
239692 Fts5ExprCtx *p = (Fts5ExprCtx*)pCtx;
243979 PoslistOffsetsCtx *pCtx = (PoslistOffsetsCtx*)pContext;
243987 iVal += pCtx->iRead - 2;
243988 pCtx->iRead = iVal;
243989 if( fts5IndexColsetTest(pCtx->pColset, iVal) ){
243990 fts5BufferSafeAppendVarint(pCtx->pBuf, iVal + 2 - pCtx->iWrite);
243991 pCtx->iWrite = iVal;
244002 PoslistCallbackCtx *pCtx = (PoslistCallbackCtx*)pContext;
244011 if( pCtx->eState==2 ){
244014 if( fts5IndexColsetTest(pCtx->pColset, iCol) ){
244015 pCtx->eState = 1;
244016 fts5BufferSafeAppendVarint(pCtx->pBuf, 1);
244018 pCtx->eState = 0;
244027 if( pCtx->eState ){
244028 fts5BufferSafeAppendBlob(pCtx->pBuf, &pChunk[iStart], i-iStart);
244035 pCtx->eState = 2;
244038 pCtx->eState = fts5IndexColsetTest(pCtx->pColset, iCol);
244039 if( pCtx->eState ){
244040 fts5BufferSafeAppendBlob(pCtx->pBuf, &pChunk[iStart], i-iStart);
244052 void *pCtx, /* Context pointer for xChunk callback */
244070 xChunk(p, pCtx, pChunk, nChunk);
245218 void *pCtx,
245221 Fts5SegWriter *pWriter = (Fts5SegWriter*)pCtx;
249028 sqlite3_context *pCtx, /* Function call context */
249040 int eDetailNone = (sqlite3_user_data(pCtx)!=0);
249250 sqlite3_result_text(pCtx, (const char*)s.p, s.n, SQLITE_TRANSIENT);
249252 sqlite3_result_error_code(pCtx, rc);
249263 sqlite3_context *pCtx, /* Function call context */
249269 sqlite3_result_error(pCtx, "should be: fts5_rowid(subject, ....)", -1);
249276 sqlite3_result_error(pCtx,
249283 sqlite3_result_int64(pCtx, iRowid);
249286 sqlite3_result_error(pCtx,
251455 static void *fts5ApiUserData(Fts5Context *pCtx){
251456 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251460 static int fts5ApiColumnCount(Fts5Context *pCtx){
251461 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251466 Fts5Context *pCtx,
251470 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251475 static int fts5ApiRowCount(Fts5Context *pCtx, i64 *pnRow){
251476 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251482 Fts5Context *pCtx,
251487 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251494 static int fts5ApiPhraseCount(Fts5Context *pCtx){
251495 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251499 static int fts5ApiPhraseSize(Fts5Context *pCtx, int iPhrase){
251500 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251505 Fts5Context *pCtx,
251511 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251663 static int fts5ApiInstCount(Fts5Context *pCtx, int *pnInst){
251664 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251674 Fts5Context *pCtx,
251680 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251696 static sqlite3_int64 fts5ApiRowid(Fts5Context *pCtx){
251697 return fts5CursorRowid((Fts5Cursor*)pCtx);
251717 static int fts5ApiColumnSize(Fts5Context *pCtx, int iCol, int *pnToken){
251718 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251741 rc = fts5ApiColumnText(pCtx, i, &z, &n);
251771 Fts5Context *pCtx, /* Fts5 context */
251775 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251805 static void *fts5ApiGetAuxdata(Fts5Context *pCtx, int bClear){
251806 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251848 Fts5Context *pCtx,
251853 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251861 fts5ApiPhraseNext(pCtx, pIter, piCol, piOff);
251867 Fts5Context *pCtx,
251871 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251897 Fts5Context *pCtx,
251903 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251920 fts5ApiPhraseNextColumn(pCtx, pIter, piCol);
251945 Fts5Context* pCtx,
251951 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
251959 Fts5Context *pCtx,
251964 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
252018 Fts5Context *pCtx,
252023 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
252131 static int fts5PoslistBlob(sqlite3_context *pCtx, Fts5Cursor *pCsr){
252180 sqlite3_result_blob(pCtx, val.p, val.n, sqlite3_free);
252190 sqlite3_context *pCtx, /* Context for sqlite3_result_xxx() calls */
252202 sqlite3_result_int64(pCtx, pCsr->iSpecial);
252211 sqlite3_result_int64(pCtx, pCsr->iCsrId);
252216 fts5PoslistBlob(pCtx, pCsr);
252222 fts5ApiInvoke(pCsr->pRank, pCsr, pCtx, pCsr->nRankArg, pCsr->apRankArg);
252229 sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1));
252232 }else if( pConfig->bContentlessDelete && sqlite3_vtab_nochange(pCtx) ){
252236 sqlite3_result_error(pCtx, zErr, -1);
252497 static void fts5ModuleDestroy(void *pCtx){
252500 Fts5Global *pGlobal = (Fts5Global*)pCtx;
252518 sqlite3_context *pCtx, /* Function call context */
252522 Fts5Global *pGlobal = (Fts5Global*)sqlite3_user_data(pCtx);
252534 sqlite3_context *pCtx, /* Function call context */
252540 …sqlite3_result_text(pCtx, "fts5: 2024-08-13 09:16:08 c9c2ab54ba1f5f46360f1b4f35d849cd3f080e6fc2b6c…
253104 Fts5InsertCtx *pCtx = (Fts5InsertCtx*)pContext;
253105 Fts5Index *pIdx = pCtx->pStorage->pIndex;
253108 if( (tflags & FTS5_TOKEN_COLOCATED)==0 || pCtx->szCol==0 ){
253109 pCtx->szCol++;
253111 return sqlite3Fts5IndexWrite(pIdx, pCtx->iCol, pCtx->szCol-1, pToken, nToken);
253598 Fts5IntegrityCtx *pCtx = (Fts5IntegrityCtx*)pContext;
253599 Fts5Termset *pTermset = pCtx->pTermset;
253609 if( (tflags & FTS5_TOKEN_COLOCATED)==0 || pCtx->szCol==0 ){
253610 pCtx->szCol++;
253613 switch( pCtx->pConfig->eDetail ){
253615 iPos = pCtx->szCol-1;
253616 iCol = pCtx->iCol;
253620 iPos = pCtx->iCol;
253625 assert( pCtx->pConfig->eDetail==FTS5_DETAIL_NONE );
253633 pCtx->cksum ^= sqlite3Fts5IndexEntryCksum(
253634 pCtx->iRowid, iCol, iPos, 0, pToken, nToken
253638 for(ii=0; rc==SQLITE_OK && ii<pCtx->pConfig->nPrefix; ii++){
253639 const int nChar = pCtx->pConfig->aPrefix[ii];
253644 pCtx->cksum ^= sqlite3Fts5IndexEntryCksum(
253645 pCtx->iRowid, iCol, iPos, ii+1, pToken, nByte
254063 void *pCtx,
254109 rc = xToken(pCtx, 0, pFold, nByte, is, ie);
254390 void *pCtx,
254484 rc = xToken(pCtx, 0, aFold, zOut-aFold, is, ie);
254524 void *pCtx,
254528 fts5_api *pApi = (fts5_api*)pCtx;
254561 void *pCtx;
255126 void *pCtx,
255133 PorterContext *p = (PorterContext*)pCtx;
255185 return p->xToken(p->pCtx, tflags, aBuf, nBuf, iStart, iEnd);
255188 return p->xToken(p->pCtx, tflags, pToken, nToken, iStart, iEnd);
255196 void *pCtx,
255204 sCtx.pCtx = pCtx;
255283 void *pCtx,
255332 rc = xToken(pCtx, 0, aBuf, zOut-aBuf, aStart[0], iNext);
257210 sqlite3_context *pCtx, /* Context for sqlite3_result_xxx() calls */
257220 pCtx, (const char*)pCsr->term.p, pCsr->term.n, SQLITE_TRANSIENT
257227 sqlite3_result_text(pCtx, z, -1, SQLITE_STATIC);
257245 sqlite3_result_int64(pCtx, pCsr->pIter->iRowid);
257256 sqlite3_result_text(pCtx, z, -1, SQLITE_STATIC);
257264 sqlite3_result_int(pCtx, ii);
257271 if( iVal>0 ) sqlite3_result_int64(pCtx, iVal);