Lines Matching refs:pCtx
3160 void *pCtx
8452 void *pCtx, /* Copy of third arg to preupdate_hook() */
8910 void *pCtx, /* Copy of third arg to _filter_table() */
8913 void *pCtx /* First argument passed to xFilter */
9762 void *pCtx, /* Copy of sixth arg to _apply() */
9766 void *pCtx, /* Copy of sixth arg to _apply() */
9770 void *pCtx /* First argument passed to xConflict */
9963 void *pCtx, /* Copy of sixth arg to _apply() */
9967 void *pCtx, /* Copy of sixth arg to _apply() */
9971 void *pCtx /* First argument passed to xConflict */
10065 sqlite3_context *pCtx, /* Context for returning result/error */
10301 void *pCtx, /* Context passed to xToken() */
10479 ** xToken(pCtx, 0, "i", 1, 0, 1);
10480 ** xToken(pCtx, 0, "won", 3, 2, 5);
10481 ** xToken(pCtx, 0, "first", 5, 6, 11);
10482 ** xToken(pCtx, FTS5_TOKEN_COLOCATED, "1st", 3, 6, 11);
10483 ** xToken(pCtx, 0, "place", 5, 12, 17);
10530 void *pCtx,
10534 void *pCtx, /* Copy of 2nd argument to xTokenize() */
12412 sqlite3_context *pCtx; /* Used when p4type is P4_FUNCCTX */
19026 sqlite3_context *pCtx, /* Write error here if one occurs */
19059 sqlite3_result_error(pCtx, "local time unavailable", -1);
19100 ** to context pCtx. If the error is an unrecognized modifier, no error is
19101 ** written to pCtx.
19103 static int parseModifier(sqlite3_context *pCtx, const char *zMod, DateTime *p){
19123 p->iJD += localtimeOffset(p, pCtx, &rc);
19146 c1 = localtimeOffset(p, pCtx, &rc);
19150 p->iJD += c1 - localtimeOffset(p, pCtx, &rc);
34644 afpLockingContext *pCtx;
34645 pNew->lockingContext = pCtx = sqlite3_malloc64( sizeof(*pCtx) );
34646 if( pCtx==0 ){
34652 pCtx->dbPath = zFilename;
34653 pCtx->reserved = 0;
36015 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
36016 unixFile *conchFile = pCtx->conchFile;
36019 char *cPath = pCtx->conchFilePath;
36075 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
36076 unixFile *conchFile = pCtx->conchFile;
36153 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
36155 if( pCtx->conchHeld!=0 ){
36158 unixFile *conchFile = pCtx->conchFile;
36172 (pCtx->lockProxyPath ? pCtx->lockProxyPath : ":auto:"),
36208 if( !pCtx->lockProxyPath ){
36226 && !strncmp(pCtx->lockProxyPath, &readBuf[PROXY_PATHINDEX],
36241 if( !pCtx->lockProxyPath ){
36242 proxyGetLockPath(pCtx->dbPath, lockPath, MAXPATHLEN);
36269 if( pCtx->lockProxyPath!=NULL ){
36270 strlcpy(&writeBuffer[PROXY_PATHINDEX], pCtx->lockProxyPath,
36320 fd = robust_open(pCtx->dbPath, pFile->openFlags, 0);
36329 if( rc==SQLITE_OK && !pCtx->lockProxy ){
36330 char *path = tempLockPath ? tempLockPath : pCtx->lockProxyPath;
36331 rc = proxyCreateUnixFile(path, &pCtx->lockProxy, 1);
36346 pCtx->lockProxyPath = sqlite3DbStrDup(0, tempLockPath);
36347 if( !pCtx->lockProxyPath ){
36353 pCtx->conchHeld = 1;
36355 if( pCtx->lockProxy->pMethod == &afpIoMethods ){
36357 afpCtx = (afpLockingContext *)pCtx->lockProxy->lockingContext;
36358 afpCtx->dbPath = pCtx->lockProxyPath;
36376 proxyLockingContext *pCtx; /* The locking context for the proxy lock */
36379 pCtx = (proxyLockingContext *)pFile->lockingContext;
36380 conchFile = pCtx->conchFile;
36382 (pCtx->lockProxyPath ? pCtx->lockProxyPath : ":auto:"),
36384 if( pCtx->conchHeld>0 ){
36387 pCtx->conchHeld = 0;
36442 proxyLockingContext *pCtx = (proxyLockingContext*)pFile->lockingContext;
36443 char *oldPath = pCtx->lockProxyPath;
36455 unixFile *lockProxy = pCtx->lockProxy;
36456 pCtx->lockProxy=NULL;
36457 pCtx->conchHeld = 0;
36464 pCtx->lockProxyPath = sqlite3DbStrDup(0, path);
36509 proxyLockingContext *pCtx;
36527 pCtx = sqlite3_malloc64( sizeof(*pCtx) );
36528 if( pCtx==0 ){
36531 memset(pCtx, 0, sizeof(*pCtx));
36533 rc = proxyCreateConchPathname(dbPath, &pCtx->conchFilePath);
36535 rc = proxyCreateUnixFile(pCtx->conchFilePath, &pCtx->conchFile, 0);
36546 if( osStat(pCtx->conchFilePath, &conchInfo) == -1 ) {
36553 pCtx->conchHeld = -1; /* read only FS/ lockless */
36559 pCtx->lockProxyPath = sqlite3DbStrDup(0, lockPath);
36563 pCtx->dbPath = sqlite3DbStrDup(0, dbPath);
36564 if( pCtx->dbPath==NULL ){
36572 pCtx->oldLockingContext = pFile->lockingContext;
36573 pFile->lockingContext = pCtx;
36574 pCtx->pOldMethod = pFile->pMethod;
36577 if( pCtx->conchFile ){
36578 pCtx->conchFile->pMethod->xClose((sqlite3_file *)pCtx->conchFile);
36579 sqlite3_free(pCtx->conchFile);
36581 sqlite3DbFree(0, pCtx->lockProxyPath);
36582 sqlite3_free(pCtx->conchFilePath);
36583 sqlite3_free(pCtx);
36600 proxyLockingContext *pCtx = (proxyLockingContext*)pFile->lockingContext;
36602 if( pCtx->lockProxyPath ){
36603 *(const char **)pArg = pCtx->lockProxyPath;
36630 proxyLockingContext *pCtx =
36633 || (pCtx->lockProxyPath &&
36634 !strncmp(pCtx->lockProxyPath, proxyPath, MAXPATHLEN))
36672 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
36673 if( pCtx->conchHeld>0 ){
36674 unixFile *proxy = pCtx->lockProxy;
36711 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
36712 if( pCtx->conchHeld>0 ){
36713 unixFile *proxy = pCtx->lockProxy;
36735 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
36736 if( pCtx->conchHeld>0 ){
36737 unixFile *proxy = pCtx->lockProxy;
36753 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
36754 unixFile *lockProxy = pCtx->lockProxy;
36755 unixFile *conchFile = pCtx->conchFile;
36764 pCtx->lockProxy = 0;
36767 if( pCtx->conchHeld ){
36775 sqlite3DbFree(0, pCtx->lockProxyPath);
36776 sqlite3_free(pCtx->conchFilePath);
36777 sqlite3DbFree(0, pCtx->dbPath);
36779 pFile->lockingContext = pCtx->oldLockingContext;
36780 pFile->pMethod = pCtx->pOldMethod;
36781 sqlite3_free(pCtx);
49273 ** Parameter iPg is the page number of said page. The pCtx argument
49282 static int pagerUndoCallback(void *pCtx, Pgno iPg){
49284 Pager *pPager = (Pager *)pCtx;
69824 struct ValueNewStat4Ctx *pCtx /* Second argument for valueNew() */
69835 assert( pCtx!=0 );
69859 pVal = valueNew(db, pCtx);
69865 assert( pCtx->pParse->rc==SQLITE_OK );
69872 sqlite3ErrorMsg(pCtx->pParse, "%s", sqlite3_value_text(pVal));
69879 pCtx->pParse->nErr++;
69882 pCtx->pParse->rc = rc;
69907 ** If pCtx is NULL and an error occurs after the sqlite3_value object
69908 ** has been allocated, it is freed before returning. Or, if pCtx is not
69918 struct ValueNewStat4Ctx *pCtx /* Second argument for valueNew() */
69935 ** on a table column definition, and hence only when pCtx==0. This
69938 assert( (pExpr->flags & EP_TokenOnly)==0 || pCtx==0 );
69942 rc = valueFromExpr(db, pExpr->pLeft, enc, aff, ppVal, pCtx);
69963 pVal = valueNew(db, pCtx);
69998 pVal = valueNew(db, pCtx);
70006 pVal = valueNew(db, pCtx);
70017 else if( op==TK_FUNCTION && pCtx!=0 ){
70018 rc = valueFromFunction(db, pExpr, enc, affinity, &pVal, pCtx);
70030 if( pCtx==0 ) sqlite3ValueFree(pVal);
70032 assert( pCtx==0 ); sqlite3ValueFree(pVal);
71626 FuncDef *pDef = pOp->p4.pCtx->pFunc;
75243 sqlite3_context *pCtx, /* Function context */
75249 if( sqlite3VdbeMemSetStr(pCtx->pOut, z, n, enc, xDel)==SQLITE_TOOBIG ){
75250 sqlite3_result_error_toobig(pCtx);
75256 sqlite3_context *pCtx /* Set a SQLITE_TOOBIG error if no NULL */
75266 if( pCtx ) sqlite3_result_error_toobig(pCtx);
75270 sqlite3_context *pCtx,
75276 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
75277 setResultStrOrError(pCtx, z, n, 0, xDel);
75280 sqlite3_context *pCtx,
75285 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
75288 (void)invokeValueDestructor(z, xDel, pCtx);
75290 setResultStrOrError(pCtx, z, (int)n, 0, xDel);
75293 SQLITE_API void SQLITE_STDCALL sqlite3_result_double(sqlite3_context *pCtx, double rVal){
75294 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
75295 sqlite3VdbeMemSetDouble(pCtx->pOut, rVal);
75297 SQLITE_API void SQLITE_STDCALL sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){
75298 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
75299 pCtx->isError = SQLITE_ERROR;
75300 pCtx->fErrorOrAux = 1;
75301 sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);
75304 SQLITE_API void SQLITE_STDCALL sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){
75305 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
75306 pCtx->isError = SQLITE_ERROR;
75307 pCtx->fErrorOrAux = 1;
75308 sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);
75311 SQLITE_API void SQLITE_STDCALL sqlite3_result_int(sqlite3_context *pCtx, int iVal){
75312 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
75313 sqlite3VdbeMemSetInt64(pCtx->pOut, (i64)iVal);
75315 SQLITE_API void SQLITE_STDCALL sqlite3_result_int64(sqlite3_context *pCtx, i64 iVal){
75316 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
75317 sqlite3VdbeMemSetInt64(pCtx->pOut, iVal);
75319 SQLITE_API void SQLITE_STDCALL sqlite3_result_null(sqlite3_context *pCtx){
75320 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
75321 sqlite3VdbeMemSetNull(pCtx->pOut);
75323 SQLITE_API void SQLITE_STDCALL sqlite3_result_subtype(sqlite3_context *pCtx, unsigned int eSubtype){
75324 Mem *pOut = pCtx->pOut;
75330 sqlite3_context *pCtx,
75335 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
75336 setResultStrOrError(pCtx, z, n, SQLITE_UTF8, xDel);
75339 sqlite3_context *pCtx,
75345 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
75349 (void)invokeValueDestructor(z, xDel, pCtx);
75351 setResultStrOrError(pCtx, z, (int)n, enc, xDel);
75356 sqlite3_context *pCtx,
75361 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
75362 setResultStrOrError(pCtx, z, n, SQLITE_UTF16NATIVE, xDel);
75365 sqlite3_context *pCtx,
75370 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
75371 setResultStrOrError(pCtx, z, n, SQLITE_UTF16BE, xDel);
75374 sqlite3_context *pCtx,
75379 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
75380 setResultStrOrError(pCtx, z, n, SQLITE_UTF16LE, xDel);
75383 SQLITE_API void SQLITE_STDCALL sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){
75384 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
75385 sqlite3VdbeMemCopy(pCtx->pOut, pValue);
75387 SQLITE_API void SQLITE_STDCALL sqlite3_result_zeroblob(sqlite3_context *pCtx, int n){
75388 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
75389 sqlite3VdbeMemSetZeroBlob(pCtx->pOut, n);
75391 SQLITE_API int SQLITE_STDCALL sqlite3_result_zeroblob64(sqlite3_context *pCtx, u64 n){
75392 Mem *pOut = pCtx->pOut;
75397 sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n);
75400 SQLITE_API void SQLITE_STDCALL sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){
75401 pCtx->isError = errCode;
75402 pCtx->fErrorOrAux = 1;
75404 if( pCtx->pVdbe ) pCtx->pVdbe->rcApp = errCode;
75406 if( pCtx->pOut->flags & MEM_Null ){
75407 sqlite3VdbeMemSetStr(pCtx->pOut, sqlite3ErrStr(errCode), -1,
75413 SQLITE_API void SQLITE_STDCALL sqlite3_result_error_toobig(sqlite3_context *pCtx){
75414 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
75415 pCtx->isError = SQLITE_TOOBIG;
75416 pCtx->fErrorOrAux = 1;
75417 sqlite3VdbeMemSetStr(pCtx->pOut, "string or blob too big", -1,
75422 SQLITE_API void SQLITE_STDCALL sqlite3_result_error_nomem(sqlite3_context *pCtx){
75423 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
75424 sqlite3VdbeMemSetNull(pCtx->pOut);
75425 pCtx->isError = SQLITE_NOMEM_BKPT;
75426 pCtx->fErrorOrAux = 1;
75427 sqlite3OomFault(pCtx->pOut->db);
75749 ** the user-function defined by pCtx.
75751 SQLITE_API void *SQLITE_STDCALL sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){
75754 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
75756 if( pCtx->pVdbe==0 ) return 0;
75758 assert( pCtx->pVdbe!=0 );
75760 for(pAuxData=pCtx->pVdbe->pAuxData; pAuxData; pAuxData=pAuxData->pNext){
75761 if( pAuxData->iOp==pCtx->iOp && pAuxData->iArg==iArg ) break;
75769 ** argument to the user-function defined by pCtx. Any previous value is
75773 sqlite3_context *pCtx,
75779 Vdbe *pVdbe = pCtx->pVdbe;
75781 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
75790 if( pAuxData->iOp==pCtx->iOp && pAuxData->iArg==iArg ) break;
75795 pAuxData->iOp = pCtx->iOp;
75799 if( pCtx->fErrorOrAux==0 ){
75800 pCtx->isError = 0;
75801 pCtx->fErrorOrAux = 1;
78766 sqlite3_context *pCtx;
78773 pCtx = sqlite3DbMallocRawNN(db, sizeof(*pCtx) + (n-1)*sizeof(sqlite3_value*));
78774 if( pCtx==0 ) goto no_mem;
78775 pCtx->pOut = 0;
78776 pCtx->pFunc = pOp->p4.pFunc;
78777 pCtx->iOp = (int)(pOp - aOp);
78778 pCtx->pVdbe = p;
78779 pCtx->argc = n;
78781 pOp->p4.pCtx = pCtx;
78787 sqlite3_context *pCtx;
78790 pCtx = pOp->p4.pCtx;
78797 if( pCtx->pOut != pOut ){
78798 pCtx->pOut = pOut;
78799 for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i];
78802 memAboutToChange(p, pCtx->pOut);
78804 for(i=0; i<pCtx->argc; i++){
78805 assert( memIsValid(pCtx->argv[i]) );
78806 REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]);
78809 MemSetTypeFlag(pCtx->pOut, MEM_Null);
78810 pCtx->fErrorOrAux = 0;
78812 (*pCtx->pFunc->xSFunc)(pCtx, pCtx->argc, pCtx->argv);/* IMP: R-24505-23230 */
78816 if( pCtx->fErrorOrAux ){
78817 if( pCtx->isError ){
78818 sqlite3VdbeError(p, "%s", sqlite3_value_text(pCtx->pOut));
78819 rc = pCtx->isError;
78821 sqlite3VdbeDeleteAuxData(db, &p->pAuxData, pCtx->iOp, pOp->p1);
78827 sqlite3VdbeChangeEncoding(pCtx->pOut, encoding);
78828 if( sqlite3VdbeMemTooBig(pCtx->pOut) ) goto too_big;
78831 REGISTER_TRACE(pOp->p3, pCtx->pOut);
78832 UPDATE_MAX_BLOBSIZE(pCtx->pOut);
83149 sqlite3_context *pCtx;
83156 pCtx = sqlite3DbMallocRawNN(db, sizeof(*pCtx) + (n-1)*sizeof(sqlite3_value*));
83157 if( pCtx==0 ) goto no_mem;
83158 pCtx->pMem = 0;
83159 pCtx->pFunc = pOp->p4.pFunc;
83160 pCtx->iOp = (int)(pOp - aOp);
83161 pCtx->pVdbe = p;
83162 pCtx->argc = n;
83164 pOp->p4.pCtx = pCtx;
83170 sqlite3_context *pCtx;
83175 pCtx = pOp->p4.pCtx;
83182 if( pCtx->pMem != pMem ){
83183 pCtx->pMem = pMem;
83184 for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i];
83188 for(i=0; i<pCtx->argc; i++){
83189 assert( memIsValid(pCtx->argv[i]) );
83190 REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]);
83196 pCtx->pOut = &t;
83197 pCtx->fErrorOrAux = 0;
83198 pCtx->skipFlag = 0;
83199 (pCtx->pFunc->xSFunc)(pCtx,pCtx->argc,pCtx->argv); /* IMP: R-24505-23230 */
83200 if( pCtx->fErrorOrAux ){
83201 if( pCtx->isError ){
83203 rc = pCtx->isError;
83210 if( pCtx->skipFlag ){
86301 static void *vdbeSorterFlushThread(void *pCtx){
86302 SortSubtask *pTask = (SortSubtask*)pCtx;
86353 void *pCtx = (void*)pTask;
86371 rc = vdbeSorterCreateThread(pTask, vdbeSorterFlushThread, pCtx);
86532 static void *vdbeIncrPopulateThread(void *pCtx){
86533 IncrMerger *pIncr = (IncrMerger*)pCtx;
86862 static void *vdbePmaReaderBgIncrInit(void *pCtx){
86863 PmaReader *pReader = (PmaReader*)pCtx;
86890 void *pCtx = (void*)pReadr;
86891 rc = vdbeSorterCreateThread(pIncr->pTask, vdbePmaReaderBgIncrInit, pCtx);
122208 VtabCtx *pCtx;
122211 for(pCtx=db->pVtabCtx; pCtx; pCtx=pCtx->pPrior){
122212 if( pCtx->pTab==pTab ){
122434 VtabCtx *pCtx;
122446 pCtx = db->pVtabCtx;
122447 if( !pCtx || pCtx->bDeclared ){
122452 pTab = pCtx->pTab;
122478 if( !HasRowid(pNew) && pCtx->pVTable->pMod->pModule->xUpdate!=0 ){
122489 pCtx->bDeclared = 1;
138811 void* pCtx,
138871 pColl->pUser = pCtx;
139634 void* pCtx,
139637 return sqlite3_create_collation_v2(db, zName, enc, pCtx, xCompare, 0);
139647 void* pCtx,
139658 rc = createCollation(db, zName, (u8)enc, pCtx, xCompare, xDel);
139672 void* pCtx,
139685 rc = createCollation(db, zName8, (u8)enc, pCtx, xCompare, 0);
145057 sqlite3_context *pCtx, /* Context for sqlite3_result_xxx() calls */
145071 sqlite3_result_int64(pCtx, pCsr->iPrevId);
145075 sqlite3_result_blob(pCtx, &pCsr, sizeof(pCsr), SQLITE_TRANSIENT);
145077 sqlite3_result_int64(pCtx, pCsr->iLangid);
145089 sqlite3_result_int(pCtx, iLangid);
145091 sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1));
148146 sqlite3_context *pCtx, /* Context for sqlite3_result_xxx() calls */
148154 sqlite3_result_text(pCtx, p->csr.zTerm, p->csr.nTerm, SQLITE_TRANSIENT);
148159 sqlite3_result_int(pCtx, p->iCol-1);
148161 sqlite3_result_text(pCtx, "*", -1, SQLITE_STATIC);
148166 sqlite3_result_int64(pCtx, p->aStat[p->iCol].nDoc);
148170 sqlite3_result_int64(pCtx, p->aStat[p->iCol].nOcc);
148175 sqlite3_result_int(pCtx, p->iLangid);
148334 sqlite3_context *pCtx; /* Write error message here */
151731 sqlite3_context *pCtx, /* Context for sqlite3_result_xxx() calls */
151739 sqlite3_result_text(pCtx, pCsr->zInput, -1, SQLITE_TRANSIENT);
151742 sqlite3_result_text(pCtx, pCsr->zToken, pCsr->nToken, SQLITE_TRANSIENT);
151745 sqlite3_result_int(pCtx, pCsr->iStart);
151748 sqlite3_result_int(pCtx, pCsr->iEnd);
151752 sqlite3_result_int(pCtx, pCsr->iPos);
157738 void *pCtx /* Second argument to pass to callback */
157745 rc = fts3ExprIterate2(pExpr->pLeft, piPhrase, x, pCtx);
157747 rc = fts3ExprIterate2(pExpr->pRight, piPhrase, x, pCtx);
157750 rc = x(pExpr, *piPhrase, pCtx);
157769 void *pCtx /* Second argument to pass to callback */
157772 return fts3ExprIterate2(pExpr, &iPhrase, x, pCtx);
158405 ** Argument pCtx is actually a pointer to a struct of type MatchInfo. This
158426 void *pCtx /* Pointer to MatchInfo structure */
158428 MatchInfo *p = (MatchInfo *)pCtx;
158442 void *pCtx /* Pointer to MatchInfo structure */
158445 MatchInfo *p = (MatchInfo *)pCtx;
158565 void *pCtx /* Pointer to MatchInfo structure */
158567 LcsIterator *aIter = (LcsIterator *)pCtx;
158802 sqlite3_context *pCtx, /* Return results here */
158843 sqlite3_result_error(pCtx, zErr, -1);
158875 sqlite3_result_error_code(pCtx, rc);
158879 sqlite3_result_blob(pCtx, aOut, n, xDestroyOut);
158887 sqlite3_context *pCtx, /* SQLite function call context */
158913 sqlite3_result_text(pCtx, "", 0, SQLITE_STATIC);
158977 sqlite3_result_error_code(pCtx, rc);
158980 sqlite3_result_text(pCtx, res.z, -1, sqlite3_free);
159035 sqlite3_context *pCtx, /* SQLite function call context */
159047 sqlite3_result_text(pCtx, "", 0, SQLITE_STATIC);
159161 sqlite3_result_error_code(pCtx, rc);
159164 sqlite3_result_text(pCtx, res.z, res.n-1, sqlite3_free);
163765 sqlite3_context *pCtx, /* SQLite scalar function context */
163772 sqlite3_result_error(pCtx, zBuf, -1);
163941 ** Collation sequence destructor function. The pCtx argument points to
163944 static void icuCollationDel(void *pCtx){
163945 UCollator *p = (UCollator *)pCtx;
163950 ** Collation sequence comparison function. The pCtx argument points to
163954 void *pCtx,
163961 UCollator *p = (UCollator *)pCtx;
165809 sqlite3_context *pCtx,
165813 sqlite3rbu *p = sqlite3_user_data(pCtx);
165821 sqlite3_result_text(pCtx, zIn, -1, SQLITE_STATIC);
165828 sqlite3_result_text(pCtx, &zIn[i+1], -1, SQLITE_STATIC);
166824 sqlite3_context *pCtx,
166828 sqlite3rbu *p = sqlite3_user_data(pCtx);
166849 sqlite3_result_error_code(pCtx, rc);
168306 sqlite3_context *pCtx,
168310 sqlite3rbu *p = (sqlite3rbu*)sqlite3_user_data(pCtx);
168322 sqlite3_result_error(pCtx, zErrmsg, -1);
168330 sqlite3_result_int(pCtx, nIndex);
168332 sqlite3_result_error(pCtx, sqlite3_errmsg(p->dbMain), -1);
170374 void *pCtx;
170392 int (*xTableFilter)(void *pCtx, const char *zTab);
170806 assert( pTab->nCol==pSession->hook.xCount(pSession->hook.pCtx) );
170814 rc = pSession->hook.xNew(pSession->hook.pCtx, i, &pVal);
170816 rc = pSession->hook.xOld(pSession->hook.pCtx, i, &pVal);
171151 rc = pSession->hook.xNew(pSession->hook.pCtx, iCol, &pVal);
171154 rc = pSession->hook.xOld(pSession->hook.pCtx, iCol, &pVal);
171414 if( pTab->nCol!=pSession->hook.xCount(pSession->hook.pCtx) ){
171454 TESTONLY(int trc = ) pSession->hook.xOld(pSession->hook.pCtx, i, &p);
171457 TESTONLY(int trc = ) pSession->hook.xNew(pSession->hook.pCtx, i, &p);
171485 pSession->hook.xOld(pSession->hook.pCtx, i, &p);
171487 pSession->hook.xNew(pSession->hook.pCtx, i, &p);
171493 if( pSession->bIndirect || pSession->hook.xDepth(pSession->hook.pCtx) ){
171504 if( pSession->hook.xDepth(pSession->hook.pCtx)==0
171556 void *pCtx, /* Copy of third arg to preupdate_hook() */
171569 for(pSession=(sqlite3_session *)pCtx; pSession; pSession=pSession->pNext){
171593 static int sessionPreupdateOld(void *pCtx, int iVal, sqlite3_value **ppVal){
171594 return sqlite3_preupdate_old((sqlite3*)pCtx, iVal, ppVal);
171596 static int sessionPreupdateNew(void *pCtx, int iVal, sqlite3_value **ppVal){
171597 return sqlite3_preupdate_new((sqlite3*)pCtx, iVal, ppVal);
171599 static int sessionPreupdateCount(void *pCtx){
171600 return sqlite3_preupdate_count((sqlite3*)pCtx);
171602 static int sessionPreupdateDepth(void *pCtx){
171603 return sqlite3_preupdate_depth((sqlite3*)pCtx);
171613 pSession->hook.pCtx = (void*)pSession->db;
171629 static int sessionDiffOld(void *pCtx, int iVal, sqlite3_value **ppVal){
171630 SessionDiffCtx *p = (SessionDiffCtx*)pCtx;
171634 static int sessionDiffNew(void *pCtx, int iVal, sqlite3_value **ppVal){
171635 SessionDiffCtx *p = (SessionDiffCtx*)pCtx;
171639 static int sessionDiffCount(void *pCtx){
171640 SessionDiffCtx *p = (SessionDiffCtx*)pCtx;
171643 static int sessionDiffDepth(void *pCtx){
171655 pSession->hook.pCtx = (void*)pDiffCtx;
171749 SessionDiffCtx *pDiffCtx = (SessionDiffCtx*)pSession->hook.pCtx;
171788 SessionDiffCtx *pDiffCtx = (SessionDiffCtx*)pSession->hook.pCtx;
171991 void *pCtx /* First argument passed to xFilter */
171994 pSession->pFilterCtx = pCtx;
174002 void *pCtx, /* First argument for conflict handler */
174027 res = xConflict(pCtx, eType, pIter);
174040 res = xConflict(pCtx, eType+1, pIter);
174096 void *pCtx, /* First argument for the conflict handler */
174135 SQLITE_CHANGESET_DATA, p, pIter, xConflict, pCtx, pbRetry
174139 SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, 0
174175 SQLITE_CHANGESET_DATA, p, pIter, xConflict, pCtx, pbRetry
174181 SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, 0
174194 SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, pbReplace
174217 void *pCtx /* First argument passed to xConflict */
174223 rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, &bReplace, &bRetry);
174235 rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, 0, 0);
174256 rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, 0, 0);
174275 void *pCtx /* First argument passed to xConflict */
174297 rc = sessionApplyOneWithRetry(db, pIter2, pApply, xConflict, pCtx);
174327 void *pCtx, /* Copy of sixth arg to _apply() */
174331 void *pCtx, /* Copy of fifth arg to _apply() */
174335 void *pCtx /* First argument passed to xConflict */
174364 db, pIter->bPatchset, zTab, &sApply, xConflict, pCtx
174380 schemaMismatch = (xFilter && (0==xFilter(pCtx, zNew)));
174431 rc = sessionApplyOneWithRetry(db, pIter, &sApply, xConflict, pCtx);
174442 rc = sessionRetryConstraints(db, bPatchset, zTab, &sApply, xConflict, pCtx);
174453 res = xConflict(pCtx, SQLITE_CHANGESET_FOREIGN_KEY, &sIter);
174488 void *pCtx, /* Copy of sixth arg to _apply() */
174492 void *pCtx, /* Copy of fifth arg to _apply() */
174496 void *pCtx /* First argument passed to xConflict */
174501 rc = sessionChangesetApply(db, pIter, xFilter, xConflict, pCtx);
174516 void *pCtx, /* Copy of sixth arg to _apply() */
174520 void *pCtx, /* Copy of sixth arg to _apply() */
174524 void *pCtx /* First argument passed to xConflict */
174529 rc = sessionChangesetApply(db, pIter, xFilter, xConflict, pCtx);
175092 sqlite3_context *pCtx; /* Function context - put error messages here */
175173 static void jsonInit(JsonString *p, sqlite3_context *pCtx){
175174 p->pCtx = pCtx;
175193 sqlite3_result_error_nomem(p->pCtx);
175337 sqlite3_result_error(p->pCtx, "JSON cannot hold BLOB values", -1);
175351 sqlite3_result_text64(p->pCtx, p->zBuf, p->nUsed,
175480 sqlite3_context *pCtx, /* Return value for this function */
175484 jsonInit(&s, pCtx);
175487 sqlite3_result_subtype(pCtx, JSON_SUBTYPE);
175495 sqlite3_context *pCtx, /* Return value for this function */
175501 sqlite3_result_null(pCtx);
175505 sqlite3_result_int(pCtx, 1);
175509 sqlite3_result_int(pCtx, 0);
175524 sqlite3_result_int64(pCtx, SMALLEST_INT64);
175534 sqlite3_result_int64(pCtx, i);
175547 sqlite3_result_double(pCtx, r);
175555 sqlite3_result_text(pCtx, pNode->u.zJContent, pNode->n,
175562 sqlite3_result_text(pCtx, pNode->u.zJContent+1, pNode->n-2,
175573 sqlite3_result_error_nomem(pCtx);
175619 sqlite3_result_text(pCtx, zOut, j, sqlite3_free);
175625 jsonReturnJson(pNode, pCtx, aReplace);
175844 sqlite3_context *pCtx, /* Report errors here */
175858 if( pCtx!=0 ){
175860 sqlite3_result_error_nomem(pCtx);
175862 sqlite3_result_error(pCtx, "malformed JSON", -1);
176086 ** On an error, write an error message into pCtx and increment the
176096 sqlite3_context *pCtx /* Report errors here, if not NULL */
176113 assert( zErr!=0 && pCtx!=0 );
176116 sqlite3_result_error(pCtx, zMsg, -1);
176119 sqlite3_result_error_nomem(pCtx);
176130 sqlite3_context *pCtx,
176135 sqlite3_result_error(pCtx, zMsg, -1);
176575 pStr->pCtx = ctx;
176584 pStr->pCtx = ctx;
176621 pStr->pCtx = ctx;
177259 sqlite3_context *pCtx, /* Context for returning result/error */
177495 void *pCtx, /* Context passed to xToken() */
177673 ** xToken(pCtx, 0, "i", 1, 0, 1);
177674 ** xToken(pCtx, 0, "won", 3, 2, 5);
177675 ** xToken(pCtx, 0, "first", 5, 6, 11);
177676 ** xToken(pCtx, FTS5_TOKEN_COLOCATED, "1st", 3, 6, 11);
177677 ** xToken(pCtx, 0, "place", 5, 12, 17);
177724 void *pCtx,
177728 void *pCtx, /* Copy of 2nd argument to xTokenize() */
178011 void *pCtx, /* Context passed to xToken() */
180046 sqlite3_context *pCtx, /* Context for returning result/error */
180056 sqlite3_result_error(pCtx, zErr, -1);
180077 sqlite3_result_text(pCtx, (const char*)ctx.zOut, -1, SQLITE_TRANSIENT);
180082 sqlite3_result_error_code(pCtx, rc);
180095 sqlite3_context *pCtx, /* Context for returning result/error */
180116 sqlite3_result_error(pCtx, zErr, -1);
180203 sqlite3_result_text(pCtx, (const char*)ctx.zOut, -1, SQLITE_TRANSIENT);
180205 sqlite3_result_error_code(pCtx, rc);
180321 sqlite3_context *pCtx, /* Context for returning result/error */
180370 sqlite3_result_double(pCtx, -1.0 * score);
180372 sqlite3_result_error_code(pCtx, rc);
181492 ** void *pCtx // Copy of 4th argument to sqlite3Fts5Tokenize()
181513 void *pCtx, /* Context passed to xToken() */
181518 pConfig->pTok, pCtx, flags, pText, nText, xToken
183247 TokenCtx *pCtx = (TokenCtx*)pContext;
183248 Fts5ExprPhrase *pPhrase = pCtx->pPhrase;
183253 if( pCtx->rc!=SQLITE_OK ) return pCtx->rc;
183282 pCtx->pPhrase = pPhrase = pNew;
183294 pCtx->rc = rc;
184008 sqlite3_context *pCtx, /* Function call context */
184013 Fts5Global *pGlobal = (Fts5Global*)sqlite3_user_data(pCtx);
184014 sqlite3 *db = sqlite3_context_db_handle(pCtx);
184031 sqlite3_result_error(pCtx, zErr, -1);
184044 sqlite3_result_error_nomem(pCtx);
184072 sqlite3_result_text(pCtx, zText, -1, SQLITE_TRANSIENT);
184079 sqlite3_result_error(pCtx, zErr, -1);
184082 sqlite3_result_error_code(pCtx, rc);
184091 sqlite3_context *pCtx, /* Function call context */
184095 fts5ExprFunction(pCtx, nArg, apVal, 0);
184098 sqlite3_context *pCtx, /* Function call context */
184102 fts5ExprFunction(pCtx, nArg, apVal, 1);
184111 sqlite3_context *pCtx, /* Function call context */
184117 sqlite3_result_error(pCtx,
184123 sqlite3_result_int(pCtx, sqlite3Fts5UnicodeIsalnum(iCode));
184127 sqlite3_context *pCtx, /* Function call context */
184132 sqlite3_result_error(pCtx,
184140 sqlite3_result_int(pCtx, sqlite3Fts5UnicodeFold(iCode, bRemoveDiacritics));
184160 void *pCtx = (void*)pGlobal;
184164 rc = sqlite3_create_function(db, p->z, -1, SQLITE_UTF8, pCtx, p->x, 0, 0);
184255 void *pCtx, /* Copy of 2nd argument to xTokenize() */
184262 Fts5ExprCtx *p = (Fts5ExprCtx*)pCtx;
187900 PoslistOffsetsCtx *pCtx = (PoslistOffsetsCtx*)pContext;
187908 iVal += pCtx->iRead - 2;
187909 pCtx->iRead = iVal;
187910 if( fts5IndexColsetTest(pCtx->pColset, iVal) ){
187911 fts5BufferSafeAppendVarint(pCtx->pBuf, iVal + 2 - pCtx->iWrite);
187912 pCtx->iWrite = iVal;
187923 PoslistCallbackCtx *pCtx = (PoslistCallbackCtx*)pContext;
187932 if( pCtx->eState==2 ){
187935 if( fts5IndexColsetTest(pCtx->pColset, iCol) ){
187936 pCtx->eState = 1;
187937 fts5BufferSafeAppendVarint(pCtx->pBuf, 1);
187939 pCtx->eState = 0;
187948 if( pCtx->eState ){
187949 fts5BufferSafeAppendBlob(pCtx->pBuf, &pChunk[iStart], i-iStart);
187956 pCtx->eState = 2;
187959 pCtx->eState = fts5IndexColsetTest(pCtx->pColset, iCol);
187960 if( pCtx->eState ){
187961 fts5BufferSafeAppendBlob(pCtx->pBuf, &pChunk[iStart], i-iStart);
187973 void *pCtx, /* Context pointer for xChunk callback */
187991 xChunk(p, pCtx, pChunk, nChunk);
189085 void *pCtx,
189088 Fts5SegWriter *pWriter = (Fts5SegWriter*)pCtx;
191153 sqlite3_context *pCtx, /* Function call context */
191164 int eDetailNone = (sqlite3_user_data(pCtx)!=0);
191329 sqlite3_result_text(pCtx, (const char*)s.p, s.n, SQLITE_TRANSIENT);
191331 sqlite3_result_error_code(pCtx, rc);
191340 sqlite3_context *pCtx, /* Function call context */
191346 sqlite3_result_error(pCtx, "should be: fts5_rowid(subject, ....)", -1);
191353 sqlite3_result_error(pCtx,
191360 sqlite3_result_int64(pCtx, iRowid);
191363 sqlite3_result_error(pCtx,
193027 static void *fts5ApiUserData(Fts5Context *pCtx){
193028 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
193032 static int fts5ApiColumnCount(Fts5Context *pCtx){
193033 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
193038 Fts5Context *pCtx,
193042 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
193047 static int fts5ApiRowCount(Fts5Context *pCtx, i64 *pnRow){
193048 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
193054 Fts5Context *pCtx,
193059 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
193066 static int fts5ApiPhraseCount(Fts5Context *pCtx){
193067 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
193071 static int fts5ApiPhraseSize(Fts5Context *pCtx, int iPhrase){
193072 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
193077 Fts5Context *pCtx,
193083 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
193216 static int fts5ApiInstCount(Fts5Context *pCtx, int *pnInst){
193217 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
193227 Fts5Context *pCtx,
193233 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
193255 static sqlite3_int64 fts5ApiRowid(Fts5Context *pCtx){
193256 return fts5CursorRowid((Fts5Cursor*)pCtx);
193276 static int fts5ApiColumnSize(Fts5Context *pCtx, int iCol, int *pnToken){
193277 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
193300 rc = fts5ApiColumnText(pCtx, i, &z, &n);
193330 Fts5Context *pCtx, /* Fts5 context */
193334 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
193364 static void *fts5ApiGetAuxdata(Fts5Context *pCtx, int bClear){
193365 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
193407 Fts5Context *pCtx,
193412 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
193419 fts5ApiPhraseNext(pCtx, pIter, piCol, piOff);
193425 Fts5Context *pCtx,
193429 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
193455 Fts5Context *pCtx,
193461 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
193477 fts5ApiPhraseNextColumn(pCtx, pIter, piCol);
193529 Fts5Context *pCtx,
193534 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
193648 static int fts5PoslistBlob(sqlite3_context *pCtx, Fts5Cursor *pCsr){
193697 sqlite3_result_blob(pCtx, val.p, val.n, sqlite3_free);
193707 sqlite3_context *pCtx, /* Context for sqlite3_result_xxx() calls */
193719 sqlite3_result_int64(pCtx, pCsr->iSpecial);
193728 sqlite3_result_int64(pCtx, pCsr->iCsrId);
193733 fts5PoslistBlob(pCtx, pCsr);
193739 fts5ApiInvoke(pCsr->pRank, pCsr, pCtx, pCsr->nRankArg, pCsr->apRankArg);
193745 sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1));
193979 static void fts5ModuleDestroy(void *pCtx){
193982 Fts5Global *pGlobal = (Fts5Global*)pCtx;
194000 sqlite3_context *pCtx, /* Function call context */
194004 Fts5Global *pGlobal = (Fts5Global*)sqlite3_user_data(pCtx);
194010 sqlite3_result_blob(pCtx, buf, sizeof(pGlobal), SQLITE_TRANSIENT);
194017 sqlite3_context *pCtx, /* Function call context */
194023 sqlite3_result_text(pCtx, "fts5: 2016-08-11 18:53:32 a12d8059770df4bca59e321c266410344242bf7b", -1, SQLITE_TRANSIENT);
194511 Fts5InsertCtx *pCtx = (Fts5InsertCtx*)pContext;
194512 Fts5Index *pIdx = pCtx->pStorage->pIndex;
194515 if( (tflags & FTS5_TOKEN_COLOCATED)==0 || pCtx->szCol==0 ){
194516 pCtx->szCol++;
194518 return sqlite3Fts5IndexWrite(pIdx, pCtx->iCol, pCtx->szCol-1, pToken, nToken);
194952 Fts5IntegrityCtx *pCtx = (Fts5IntegrityCtx*)pContext;
194953 Fts5Termset *pTermset = pCtx->pTermset;
194963 if( (tflags & FTS5_TOKEN_COLOCATED)==0 || pCtx->szCol==0 ){
194964 pCtx->szCol++;
194967 switch( pCtx->pConfig->eDetail ){
194969 iPos = pCtx->szCol-1;
194970 iCol = pCtx->iCol;
194974 iPos = pCtx->iCol;
194979 assert( pCtx->pConfig->eDetail==FTS5_DETAIL_NONE );
194987 pCtx->cksum ^= sqlite3Fts5IndexEntryCksum(
194988 pCtx->iRowid, iCol, iPos, 0, pToken, nToken
194992 for(ii=0; rc==SQLITE_OK && ii<pCtx->pConfig->nPrefix; ii++){
194993 const int nChar = pCtx->pConfig->aPrefix[ii];
194998 pCtx->cksum ^= sqlite3Fts5IndexEntryCksum(
194999 pCtx->iRowid, iCol, iPos, ii+1, pToken, nByte
195392 void *pCtx,
195438 rc = xToken(pCtx, 0, pFold, nByte, is, ie);
195666 void *pCtx,
195760 rc = xToken(pCtx, 0, aFold, zOut-aFold, is, ie);
195800 void *pCtx,
195804 fts5_api *pApi = (fts5_api*)pCtx;
195837 void *pCtx;
196402 void *pCtx,
196409 PorterContext *p = (PorterContext*)pCtx;
196461 return p->xToken(p->pCtx, tflags, aBuf, nBuf, iStart, iEnd);
196464 return p->xToken(p->pCtx, tflags, pToken, nToken, iStart, iEnd);
196472 void *pCtx,
196480 sCtx.pCtx = pCtx;
197782 sqlite3_context *pCtx, /* Context for sqlite3_result_xxx() calls */
197792 pCtx, (const char*)pCsr->term.p, pCsr->term.n, SQLITE_TRANSIENT
197799 sqlite3_result_text(pCtx, z, -1, SQLITE_STATIC);
197815 if( iVal>0 ) sqlite3_result_int64(pCtx, iVal);