Lines Matching refs:pCtx
3664 void *pCtx
9931 int (*xAddRow)(void* pCtx, int addedRows);
9932 int (*xReset)(void* pCtx, int startPos);
9933 int (*xFinish)(void* pCtx, int addedRows, int totalRows);
9934 int (*xPutString)(void *pCtx, int addedRows, int column, const char* text, int len);
9935 int (*xPutLong)(void *pCtx, int addedRows, int column, sqlite3_int64 value);
9936 int (*xPutDouble)(void *pCtx, int addedRows, int column, double value);
9937 int (*xPutBlob)(void *pCtx, int addedRows, int column, const void* blob, int len);
9938 int (*xPutNull)(void *pCtx, int addedRows, int column);
9939 int (*xPutOther)(void *pCtx, int addedRows, int column);
10492 void *pCtx, /* Copy of third arg to preupdate_hook() */
11210 void *pCtx, /* Copy of third arg to _filter_table() */
11213 void *pCtx /* First argument passed to xFilter */
12167 void *pCtx, /* Copy of sixth arg to _apply() */
12171 void *pCtx, /* Copy of sixth arg to _apply() */
12175 void *pCtx /* First argument passed to xConflict */
12182 void *pCtx, /* Copy of sixth arg to _apply() */
12186 void *pCtx, /* Copy of sixth arg to _apply() */
12190 void *pCtx, /* First argument passed to xConflict */
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 */
12736 sqlite3_context *pCtx, /* Context for returning result/error */
12968 void *pCtx, /* Context passed to xToken() */
13146 ** xToken(pCtx, 0, "i", 1, 0, 1);
13147 ** xToken(pCtx, 0, "won", 3, 2, 5);
13148 ** xToken(pCtx, 0, "first", 5, 6, 11);
13149 ** xToken(pCtx, FTS5_TOKEN_COLOCATED, "1st", 3, 6, 11);
13150 ** xToken(pCtx, 0, "place", 5, 12, 17);
13197 void *pCtx,
13201 void *pCtx, /* Copy of 2nd argument to xTokenize() */
15896 sqlite3_context *pCtx; /* Used when p4type is P4_FUNCCTX */
24070 sqlite3_context *pCtx /* Write error here if one occurs */
24100 sqlite3_result_error(pCtx, "local time unavailable", -1);
24162 ** to context pCtx. If the error is an unrecognized modifier, no error is
24163 ** written to pCtx.
24166 sqlite3_context *pCtx, /* Function context */
24225 if( sqlite3_stricmp(z, "localtime")==0 && sqlite3NotPureFunc(pCtx) ){
24226 rc = toLocaltime(p, pCtx);
24250 else if( sqlite3_stricmp(z, "utc")==0 && sqlite3NotPureFunc(pCtx) ){
24266 rc = toLocaltime(&new, pCtx);
31044 SQLITE_PRIVATE void sqlite3ResultStrAccum(sqlite3_context *pCtx, StrAccum *p){
31046 sqlite3_result_error_code(pCtx, p->accError);
31049 sqlite3_result_text(pCtx, p->zText, p->nChar, SQLITE_DYNAMIC);
31051 sqlite3_result_text(pCtx, "", 0, SQLITE_STATIC);
42624 afpLockingContext *pCtx;
42625 pNew->lockingContext = pCtx = sqlite3_malloc64( sizeof(*pCtx) );
42626 if( pCtx==0 ){
42632 pCtx->dbPath = zFilename;
42633 pCtx->reserved = 0;
44129 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
44130 unixFile *conchFile = pCtx->conchFile;
44133 char *cPath = pCtx->conchFilePath;
44189 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
44190 unixFile *conchFile = pCtx->conchFile;
44273 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
44275 if( pCtx->conchHeld!=0 ){
44278 unixFile *conchFile = pCtx->conchFile;
44292 (pCtx->lockProxyPath ? pCtx->lockProxyPath : ":auto:"),
44331 if( !pCtx->lockProxyPath ){
44349 && !strncmp(pCtx->lockProxyPath, &readBuf[PROXY_PATHINDEX],
44364 if( !pCtx->lockProxyPath ){
44365 proxyGetLockPath(pCtx->dbPath, lockPath, MAXPATHLEN);
44392 if( pCtx->lockProxyPath!=NULL ){
44393 strlcpy(&writeBuffer[PROXY_PATHINDEX], pCtx->lockProxyPath,
44443 fd = robust_open(pCtx->dbPath, pFile->openFlags, 0);
44452 if( rc==SQLITE_OK && !pCtx->lockProxy ){
44453 char *path = tempLockPath ? tempLockPath : pCtx->lockProxyPath;
44454 rc = proxyCreateUnixFile(path, &pCtx->lockProxy, 1);
44469 pCtx->lockProxyPath = sqlite3DbStrDup(0, tempLockPath);
44470 if( !pCtx->lockProxyPath ){
44476 pCtx->conchHeld = 1;
44478 if( pCtx->lockProxy->pMethod == &afpIoMethods ){
44480 afpCtx = (afpLockingContext *)pCtx->lockProxy->lockingContext;
44481 afpCtx->dbPath = pCtx->lockProxyPath;
44499 proxyLockingContext *pCtx; /* The locking context for the proxy lock */
44502 pCtx = (proxyLockingContext *)pFile->lockingContext;
44503 conchFile = pCtx->conchFile;
44505 (pCtx->lockProxyPath ? pCtx->lockProxyPath : ":auto:"),
44507 if( pCtx->conchHeld>0 ){
44510 pCtx->conchHeld = 0;
44565 proxyLockingContext *pCtx = (proxyLockingContext*)pFile->lockingContext;
44566 char *oldPath = pCtx->lockProxyPath;
44578 unixFile *lockProxy = pCtx->lockProxy;
44579 pCtx->lockProxy=NULL;
44580 pCtx->conchHeld = 0;
44587 pCtx->lockProxyPath = sqlite3DbStrDup(0, path);
44632 proxyLockingContext *pCtx;
44650 pCtx = sqlite3_malloc64( sizeof(*pCtx) );
44651 if( pCtx==0 ){
44654 memset(pCtx, 0, sizeof(*pCtx));
44656 rc = proxyCreateConchPathname(dbPath, &pCtx->conchFilePath);
44658 rc = proxyCreateUnixFile(pCtx->conchFilePath, &pCtx->conchFile, 0);
44669 if( osStat(pCtx->conchFilePath, &conchInfo) == -1 ) {
44676 pCtx->conchHeld = -1; /* read only FS/ lockless */
44682 pCtx->lockProxyPath = sqlite3DbStrDup(0, lockPath);
44686 pCtx->dbPath = sqlite3DbStrDup(0, dbPath);
44687 if( pCtx->dbPath==NULL ){
44695 pCtx->oldLockingContext = pFile->lockingContext;
44696 pFile->lockingContext = pCtx;
44697 pCtx->pOldMethod = pFile->pMethod;
44700 if( pCtx->conchFile ){
44701 pCtx->conchFile->pMethod->xClose((sqlite3_file *)pCtx->conchFile);
44702 sqlite3_free(pCtx->conchFile);
44704 sqlite3DbFree(0, pCtx->lockProxyPath);
44705 sqlite3_free(pCtx->conchFilePath);
44706 sqlite3_free(pCtx);
44723 proxyLockingContext *pCtx = (proxyLockingContext*)pFile->lockingContext;
44725 if( pCtx->lockProxyPath ){
44726 *(const char **)pArg = pCtx->lockProxyPath;
44753 proxyLockingContext *pCtx =
44756 || (pCtx->lockProxyPath &&
44757 !strncmp(pCtx->lockProxyPath, proxyPath, MAXPATHLEN))
44795 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
44796 if( pCtx->conchHeld>0 ){
44797 unixFile *proxy = pCtx->lockProxy;
44834 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
44835 if( pCtx->conchHeld>0 ){
44836 unixFile *proxy = pCtx->lockProxy;
44858 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
44859 if( pCtx->conchHeld>0 ){
44860 unixFile *proxy = pCtx->lockProxy;
44876 proxyLockingContext *pCtx = (proxyLockingContext *)pFile->lockingContext;
44877 unixFile *lockProxy = pCtx->lockProxy;
44878 unixFile *conchFile = pCtx->conchFile;
44887 pCtx->lockProxy = 0;
44890 if( pCtx->conchHeld ){
44898 sqlite3DbFree(0, pCtx->lockProxyPath);
44899 sqlite3_free(pCtx->conchFilePath);
44900 sqlite3DbFree(0, pCtx->dbPath);
44902 pFile->lockingContext = pCtx->oldLockingContext;
44903 pFile->pMethod = pCtx->pOldMethod;
44904 sqlite3_free(pCtx);
58613 ** Parameter iPg is the page number of said page. The pCtx argument
58622 static int pagerUndoCallback(void *pCtx, Pgno iPg){
58624 Pager *pPager = (Pager *)pCtx;
82010 struct ValueNewStat4Ctx *pCtx /* Second argument for valueNew() */
82021 assert( pCtx!=0 );
82047 pVal = valueNew(db, pCtx);
82053 testcase( pCtx->pParse->rc==SQLITE_ERROR );
82054 testcase( pCtx->pParse->rc==SQLITE_OK );
82062 sqlite3ErrorMsg(pCtx->pParse, "%s", sqlite3_value_text(pVal));
82069 pCtx->pParse->nErr++;
82072 pCtx->pParse->rc = rc;
82097 ** If pCtx is NULL and an error occurs after the sqlite3_value object
82098 ** has been allocated, it is freed before returning. Or, if pCtx is not
82108 struct ValueNewStat4Ctx *pCtx /* Second argument for valueNew() */
82122 ** on a table column definition, and hence only when pCtx==0. This
82125 assert( (pExpr->flags & EP_TokenOnly)==0 || pCtx==0 );
82131 rc = valueFromExpr(db, pExpr->pLeft, enc, aff, ppVal, pCtx);
82152 pVal = valueNew(db, pCtx);
82177 if( SQLITE_OK==valueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal,pCtx)
82196 pVal = valueNew(db, pCtx);
82206 pVal = valueNew(db, pCtx);
82216 else if( op==TK_FUNCTION && pCtx!=0 ){
82217 rc = valueFromFunction(db, pExpr, enc, affinity, &pVal, pCtx);
82222 pVal = valueNew(db, pCtx);
82234 if( pCtx==0 || NEVER(pCtx->pParse->nErr==0) )
82240 if( pCtx==0 ) sqlite3ValueFree(pVal);
82242 assert( pCtx==0 ); sqlite3ValueFree(pVal);
82907 sqlite3_context *pCtx;
82909 nByte = sizeof(*pCtx) + (nArg-1)*sizeof(sqlite3_value*);
82910 pCtx = sqlite3DbMallocRawNN(pParse->db, nByte);
82911 if( pCtx==0 ){
82916 pCtx->pOut = 0;
82917 pCtx->pFunc = (FuncDef*)pFunc;
82918 pCtx->pVdbe = 0;
82919 pCtx->isError = 0;
82920 pCtx->argc = nArg;
82921 pCtx->iOp = sqlite3VdbeCurrentAddr(v);
82923 p1, p2, p3, (char*)pCtx, P4_FUNCCTX);
84168 sqlite3_context *pCtx = pOp->p4.pCtx;
84169 if( pOp->p4type!=P4_FUNCCTX || pCtx->argc==1 ){
84171 }else if( pCtx->argc>1 ){
84172 sqlite3_str_appendf(&x, "%d..%d", v1, v1+pCtx->argc-1);
84326 FuncDef *pDef = pOp->p4.pCtx->pFunc;
87725 SQLITE_PRIVATE int sqlite3NotPureFunc(sqlite3_context *pCtx){
87728 if( pCtx->pVdbe==0 ) return 1;
87730 pOp = pCtx->pVdbe->aOp + pCtx->iOp;
87742 pCtx->pFunc->zName, zContext);
87743 sqlite3_result_error(pCtx, zMsg, -1);
88242 sqlite3_context *pCtx, /* Function context */
88248 Mem *pOut = pCtx->pOut;
88252 sqlite3_result_error_toobig(pCtx);
88257 sqlite3_result_error_nomem(pCtx);
88261 sqlite3VdbeChangeEncoding(pOut, pCtx->enc);
88263 sqlite3_result_error_toobig(pCtx);
88269 sqlite3_context *pCtx /* Set a SQLITE_TOOBIG error if no NULL */
88279 sqlite3_result_error_toobig(pCtx);
88283 sqlite3_context *pCtx,
88289 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88290 setResultStrOrError(pCtx, z, n, 0, xDel);
88293 sqlite3_context *pCtx,
88298 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88301 (void)invokeValueDestructor(z, xDel, pCtx);
88303 setResultStrOrError(pCtx, z, (int)n, 0, xDel);
88306 SQLITE_API void sqlite3_result_double(sqlite3_context *pCtx, double rVal){
88307 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88308 sqlite3VdbeMemSetDouble(pCtx->pOut, rVal);
88310 SQLITE_API void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){
88311 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88312 pCtx->isError = SQLITE_ERROR;
88313 sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);
88316 SQLITE_API void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){
88317 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88318 pCtx->isError = SQLITE_ERROR;
88319 sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);
88322 SQLITE_API void sqlite3_result_int(sqlite3_context *pCtx, int iVal){
88323 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88324 sqlite3VdbeMemSetInt64(pCtx->pOut, (i64)iVal);
88326 SQLITE_API void sqlite3_result_int64(sqlite3_context *pCtx, i64 iVal){
88327 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88328 sqlite3VdbeMemSetInt64(pCtx->pOut, iVal);
88330 SQLITE_API void sqlite3_result_null(sqlite3_context *pCtx){
88331 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88332 sqlite3VdbeMemSetNull(pCtx->pOut);
88335 sqlite3_context *pCtx,
88340 Mem *pOut = pCtx->pOut;
88346 SQLITE_API void sqlite3_result_subtype(sqlite3_context *pCtx, unsigned int eSubtype){
88347 Mem *pOut = pCtx->pOut;
88353 sqlite3_context *pCtx,
88358 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88359 setResultStrOrError(pCtx, z, n, SQLITE_UTF8, xDel);
88362 sqlite3_context *pCtx,
88368 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88372 (void)invokeValueDestructor(z, xDel, pCtx);
88374 setResultStrOrError(pCtx, z, (int)n, enc, xDel);
88379 sqlite3_context *pCtx,
88384 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88385 setResultStrOrError(pCtx, z, n, SQLITE_UTF16NATIVE, xDel);
88388 sqlite3_context *pCtx,
88393 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88394 setResultStrOrError(pCtx, z, n, SQLITE_UTF16BE, xDel);
88397 sqlite3_context *pCtx,
88402 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88403 setResultStrOrError(pCtx, z, n, SQLITE_UTF16LE, xDel);
88406 SQLITE_API void sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){
88407 Mem *pOut = pCtx->pOut;
88408 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88410 sqlite3VdbeChangeEncoding(pOut, pCtx->enc);
88412 sqlite3_result_error_toobig(pCtx);
88415 SQLITE_API void sqlite3_result_zeroblob(sqlite3_context *pCtx, int n){
88416 sqlite3_result_zeroblob64(pCtx, n>0 ? n : 0);
88418 SQLITE_API int sqlite3_result_zeroblob64(sqlite3_context *pCtx, u64 n){
88419 Mem *pOut = pCtx->pOut;
88422 sqlite3_result_error_toobig(pCtx);
88426 sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n);
88429 return sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n);
88432 SQLITE_API void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){
88433 pCtx->isError = errCode ? errCode : -1;
88435 if( pCtx->pVdbe ) pCtx->pVdbe->rcApp = errCode;
88437 if( pCtx->pOut->flags & MEM_Null ){
88438 setResultStrOrError(pCtx, sqlite3ErrStr(errCode), -1, SQLITE_UTF8,
88444 SQLITE_API void sqlite3_result_error_toobig(sqlite3_context *pCtx){
88445 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88446 pCtx->isError = SQLITE_TOOBIG;
88447 sqlite3VdbeMemSetStr(pCtx->pOut, "string or blob too big", -1,
88452 SQLITE_API void sqlite3_result_error_nomem(sqlite3_context *pCtx){
88453 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88454 sqlite3VdbeMemSetNull(pCtx->pOut);
88455 pCtx->isError = SQLITE_NOMEM_BKPT;
88456 sqlite3OomFault(pCtx->pOut->db);
88464 SQLITE_PRIVATE void sqlite3ResultIntReal(sqlite3_context *pCtx){
88465 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88466 if( pCtx->pOut->flags & MEM_Int ){
88467 pCtx->pOut->flags &= ~MEM_Int;
88468 pCtx->pOut->flags |= MEM_IntReal;
88908 ** the user-function defined by pCtx.
88916 SQLITE_API void *sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){
88919 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88921 if( pCtx->pVdbe==0 ) return 0;
88923 assert( pCtx->pVdbe!=0 );
88925 for(pAuxData=pCtx->pVdbe->pAuxData; pAuxData; pAuxData=pAuxData->pNextAux){
88926 if( pAuxData->iAuxArg==iArg && (pAuxData->iAuxOp==pCtx->iOp || iArg<0) ){
88935 ** argument to the user-function defined by pCtx. Any previous value is
88945 sqlite3_context *pCtx,
88951 Vdbe *pVdbe = pCtx->pVdbe;
88953 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
88961 if( pAuxData->iAuxArg==iArg && (pAuxData->iAuxOp==pCtx->iOp || iArg<0) ){
88968 pAuxData->iAuxOp = pCtx->iOp;
88972 if( pCtx->isError==0 ) pCtx->isError = -1;
90925 void *pCtx
90929 int rc = p->pSharedBlock->xAddRow(pCtx, p->addedRows);
90937 rc = p->pSharedBlock->xPutLong(pCtx, p->addedRows, i, (sqlite3_int64)pMem[i].u.i);
90941 rc = p->pSharedBlock->xPutDouble(pCtx, p->addedRows, i, pMem[i].u.r);
90948 rc = p->pSharedBlock->xPutString(pCtx, p->addedRows, i, pMem[i].z, pMem[i].n+1);
90952 rc = p->pSharedBlock->xPutBlob(pCtx, p->addedRows, i, pMem[i].z, pMem[i].n);
90956 rc = p->pSharedBlock->xPutNull(pCtx, p->addedRows, i);
90960 rc = p->pSharedBlock->xPutOther(pCtx, p->addedRows, i);
91927 void *pCtx = p->pSharedBlock->pContext;
91933 rc = copySharedBlockRow(p, pOp, pMem, pCtx);
91937 p->pSharedBlock->xReset(pCtx,p->startPos);
91939 rc = copySharedBlockRow(p, pOp, pMem, pCtx);
91952 p->pSharedBlock->xFinish(pCtx, p->addedRows, p->totalRows);
97850 sqlite3_context *pCtx;
97857 pCtx = sqlite3DbMallocRawNN(db, n*sizeof(sqlite3_value*) +
97858 (sizeof(pCtx[0]) + sizeof(Mem) - sizeof(sqlite3_value*)));
97859 if( pCtx==0 ) goto no_mem;
97860 pCtx->pMem = 0;
97861 pCtx->pOut = (Mem*)&(pCtx->argv[n]);
97862 sqlite3VdbeMemInit(pCtx->pOut, db, MEM_Null);
97863 pCtx->pFunc = pOp->p4.pFunc;
97864 pCtx->iOp = (int)(pOp - aOp);
97865 pCtx->pVdbe = p;
97866 pCtx->skipFlag = 0;
97867 pCtx->isError = 0;
97868 pCtx->enc = encoding;
97869 pCtx->argc = n;
97871 pOp->p4.pCtx = pCtx;
97882 sqlite3_context *pCtx;
97886 pCtx = pOp->p4.pCtx;
97904 if( pCtx->pMem != pMem ){
97905 pCtx->pMem = pMem;
97906 for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i];
97910 for(i=0; i<pCtx->argc; i++){
97911 assert( memIsValid(pCtx->argv[i]) );
97912 REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]);
97917 assert( pCtx->pOut->flags==MEM_Null );
97918 assert( pCtx->isError==0 );
97919 assert( pCtx->skipFlag==0 );
97922 (pCtx->pFunc->xInverse)(pCtx,pCtx->argc,pCtx->argv);
97925 (pCtx->pFunc->xSFunc)(pCtx,pCtx->argc,pCtx->argv); /* IMP: R-24505-23230 */
97927 if( pCtx->isError ){
97928 if( pCtx->isError>0 ){
97929 sqlite3VdbeError(p, "%s", sqlite3_value_text(pCtx->pOut));
97930 rc = pCtx->isError;
97932 if( pCtx->skipFlag ){
97936 pCtx->skipFlag = 0;
97938 sqlite3VdbeMemRelease(pCtx->pOut);
97939 pCtx->pOut->flags = MEM_Null;
97940 pCtx->isError = 0;
97943 assert( pCtx->pOut->flags==MEM_Null );
97944 assert( pCtx->skipFlag==0 );
98790 sqlite3_context *pCtx;
98793 pCtx = pOp->p4.pCtx;
98800 if( pCtx->pOut != pOut ){
98801 pCtx->pVdbe = p;
98802 pCtx->pOut = pOut;
98803 pCtx->enc = encoding;
98804 for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i];
98806 assert( pCtx->pVdbe==p );
98810 for(i=0; i<pCtx->argc; i++){
98811 assert( memIsValid(pCtx->argv[i]) );
98812 REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]);
98816 assert( pCtx->isError==0 );
98817 (*pCtx->pFunc->xSFunc)(pCtx, pCtx->argc, pCtx->argv);/* IMP: R-24505-23230 */
98820 if( pCtx->isError ){
98821 if( pCtx->isError>0 ){
98823 rc = pCtx->isError;
98825 sqlite3VdbeDeleteAuxData(db, &p->pAuxData, pCtx->iOp, pOp->p1);
98826 pCtx->isError = 0;
101459 static void *vdbeSorterFlushThread(void *pCtx){
101460 SortSubtask *pTask = (SortSubtask*)pCtx;
101511 void *pCtx;
101519 pCtx = (void*)pTask;
101532 rc = vdbeSorterCreateThread(pTask, vdbeSorterFlushThread, pCtx);
101697 static void *vdbeIncrPopulateThread(void *pCtx){
101698 IncrMerger *pIncr = (IncrMerger*)pCtx;
102033 static void *vdbePmaReaderBgIncrInit(void *pCtx){
102034 PmaReader *pReader = (PmaReader*)pCtx;
102061 void *pCtx = (void*)pReadr;
102062 rc = vdbeSorterCreateThread(pIncr->pTask, vdbePmaReaderBgIncrInit, pCtx);
113288 struct RenameCtx *pCtx,
113298 if( pCtx ){
113300 pToken->pNext = pCtx->pList;
113301 pCtx->pList = pToken;
113302 pCtx->nList++;
113360 static RenameToken *renameColumnTokenNext(RenameCtx *pCtx){
113361 RenameToken *pBest = pCtx->pList;
113368 for(pp=&pCtx->pList; *pp!=pBest; pp=&(*pp)->pNext);
113379 ** adds context to the error message and then stores it in pCtx.
113382 sqlite3_context *pCtx,
113396 sqlite3_result_error(pCtx, zErr, -1);
113404 ** to the RenameCtx pCtx.
113408 RenameCtx *pCtx,
113420 renameTokenFind(pParse, pCtx, (const void*)zName);
113429 ** from Parse object pParse and add it to the RenameCtx pCtx.
113433 RenameCtx *pCtx,
113442 renameTokenFind(pParse, pCtx, (const void*)zName);
113501 ** is loaded into context object pCtx as the result.
113504 ** pCtx and an SQLite error code returned.
113507 sqlite3_context *pCtx, /* Return result here */
113515 sqlite3 *db = sqlite3_context_db_handle(pCtx);
113597 sqlite3_result_text(pCtx, zOut, -1, SQLITE_TRANSIENT);
150508 VtabCtx *pCtx;
150514 for(pCtx=db->pVtabCtx; pCtx; pCtx=pCtx->pPrior){
150515 if( pCtx->pTab==pTab ){
150744 VtabCtx *pCtx;
150756 pCtx = db->pVtabCtx;
150757 if( !pCtx || pCtx->bDeclared ){
150762 pTab = pCtx->pTab;
150793 && pCtx->pVTable->pMod->pModule->xUpdate!=0
150808 pCtx->bDeclared = 1;
163274 sqlite3_context *pCtx,
163278 i64 *p = (i64*)sqlite3_aggregate_context(pCtx, sizeof(*p));
163283 static void row_numberValueFunc(sqlite3_context *pCtx){
163284 i64 *p = (i64*)sqlite3_aggregate_context(pCtx, sizeof(*p));
163285 sqlite3_result_int64(pCtx, (p ? *p : 0));
163305 sqlite3_context *pCtx,
163310 p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
163315 static void dense_rankValueFunc(sqlite3_context *pCtx){
163317 p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
163323 sqlite3_result_int64(pCtx, p->nValue);
163337 sqlite3_context *pCtx,
163342 p = (struct NthValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
163364 sqlite3_result_error_nomem(pCtx);
163374 pCtx, "second argument to nth_value must be a positive integer", -1
163377 static void nth_valueFinalizeFunc(sqlite3_context *pCtx){
163379 p = (struct NthValueCtx*)sqlite3_aggregate_context(pCtx, 0);
163381 sqlite3_result_value(pCtx, p->pValue);
163390 sqlite3_context *pCtx,
163395 p = (struct NthValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
163399 sqlite3_result_error_nomem(pCtx);
163405 static void first_valueFinalizeFunc(sqlite3_context *pCtx){
163407 p = (struct NthValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
163409 sqlite3_result_value(pCtx, p->pValue);
163424 sqlite3_context *pCtx,
163429 p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
163439 static void rankValueFunc(sqlite3_context *pCtx){
163441 p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
163443 sqlite3_result_int64(pCtx, p->nValue);
163455 sqlite3_context *pCtx,
163462 p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
163468 sqlite3_context *pCtx,
163475 p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
163478 static void percent_rankValueFunc(sqlite3_context *pCtx){
163480 p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
163485 sqlite3_result_double(pCtx, r);
163487 sqlite3_result_double(pCtx, 0.0);
163500 sqlite3_context *pCtx,
163507 p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
163513 sqlite3_context *pCtx,
163520 p = (struct CallCount*)sqlite3_aggregate_context(pCtx, sizeof(*p));
163523 static void cume_distValueFunc(sqlite3_context *pCtx){
163525 p = (struct CallCount*)sqlite3_aggregate_context(pCtx, 0);
163528 sqlite3_result_double(pCtx, r);
163549 sqlite3_context *pCtx,
163555 p = (struct NtileCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
163561 pCtx, "argument of ntile must be a positive integer", -1
163569 sqlite3_context *pCtx,
163576 p = (struct NtileCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
163579 static void ntileValueFunc(sqlite3_context *pCtx){
163581 p = (struct NtileCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
163585 sqlite3_result_int64(pCtx, p->iRow+1);
163594 sqlite3_result_int64(pCtx, 1 + iRow/(nSize+1));
163596 sqlite3_result_int64(pCtx, 1 + nLarge + (iRow-iSmall)/nSize);
163615 sqlite3_context *pCtx,
163621 p = (struct LastValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
163626 sqlite3_result_error_nomem(pCtx);
163633 sqlite3_context *pCtx,
163640 p = (struct LastValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
163649 static void last_valueValueFunc(sqlite3_context *pCtx){
163651 p = (struct LastValueCtx*)sqlite3_aggregate_context(pCtx, 0);
163653 sqlite3_result_value(pCtx, p->pVal);
163656 static void last_valueFinalizeFunc(sqlite3_context *pCtx){
163658 p = (struct LastValueCtx*)sqlite3_aggregate_context(pCtx, sizeof(*p));
163660 sqlite3_result_value(pCtx, p->pVal);
176129 void* pCtx,
176189 pColl->pUser = pCtx;
177053 void* pCtx,
177056 return sqlite3_create_collation_v2(db, zName, enc, pCtx, xCompare, 0);
177066 void* pCtx,
177077 rc = createCollation(db, zName, (u8)enc, pCtx, xCompare, xDel);
177091 void* pCtx,
177104 rc = createCollation(db, zName8, (u8)enc, pCtx, xCompare, 0);
177856 sqlite3_context *pCtx = va_arg(ap, sqlite3_context*);
177857 sqlite3ResultIntReal(pCtx);
183094 sqlite3_context *pCtx, /* Context for sqlite3_result_xxx() calls */
183107 sqlite3_result_pointer(pCtx, pCsr, "fts3cursor", 0);
183112 sqlite3_result_int64(pCtx, pCsr->iPrevId);
183117 sqlite3_result_int64(pCtx, pCsr->iLangid);
183120 sqlite3_result_int(pCtx, 0);
183132 sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1));
186231 sqlite3_context *pCtx, /* Context for sqlite3_result_xxx() calls */
186239 sqlite3_result_text(pCtx, p->csr.zTerm, p->csr.nTerm, SQLITE_TRANSIENT);
186244 sqlite3_result_int(pCtx, p->iCol-1);
186246 sqlite3_result_text(pCtx, "*", -1, SQLITE_STATIC);
186251 sqlite3_result_int64(pCtx, p->aStat[p->iCol].nDoc);
186255 sqlite3_result_int64(pCtx, p->aStat[p->iCol].nOcc);
186260 sqlite3_result_int(pCtx, p->iLangid);
186420 sqlite3_context *pCtx; /* Write error message here */
189806 sqlite3_context *pCtx, /* Context for sqlite3_result_xxx() calls */
189814 sqlite3_result_text(pCtx, pCsr->zInput, -1, SQLITE_TRANSIENT);
189817 sqlite3_result_text(pCtx, pCsr->zToken, pCsr->nToken, SQLITE_TRANSIENT);
189820 sqlite3_result_int(pCtx, pCsr->iStart);
189823 sqlite3_result_int(pCtx, pCsr->iEnd);
189827 sqlite3_result_int(pCtx, pCsr->iPos);
195957 void *pCtx /* Second argument to pass to callback */
195964 rc = fts3ExprIterate2(pExpr->pLeft, piPhrase, x, pCtx);
195966 rc = fts3ExprIterate2(pExpr->pRight, piPhrase, x, pCtx);
195969 rc = x(pExpr, *piPhrase, pCtx);
195988 void *pCtx /* Second argument to pass to callback */
195991 return fts3ExprIterate2(pExpr, &iPhrase, x, pCtx);
196632 ** Argument pCtx is actually a pointer to a struct of type MatchInfo. This
196653 void *pCtx /* Pointer to MatchInfo structure */
196655 MatchInfo *p = (MatchInfo *)pCtx;
196669 void *pCtx /* Pointer to MatchInfo structure */
196672 MatchInfo *p = (MatchInfo *)pCtx;
196804 void *pCtx /* Pointer to MatchInfo structure */
196806 LcsIterator *aIter = (LcsIterator *)pCtx;
197057 sqlite3_context *pCtx, /* Return results here */
197098 sqlite3_result_error(pCtx, zErr, -1);
197130 sqlite3_result_error_code(pCtx, rc);
197134 sqlite3_result_blob(pCtx, aOut, n, xDestroyOut);
197142 sqlite3_context *pCtx, /* SQLite function call context */
197168 sqlite3_result_text(pCtx, "", 0, SQLITE_STATIC);
197236 sqlite3_result_error_code(pCtx, rc);
197239 sqlite3_result_text(pCtx, res.z, -1, sqlite3_free);
197294 sqlite3_context *pCtx, /* SQLite function call context */
197306 sqlite3_result_text(pCtx, "", 0, SQLITE_STATIC);
197420 sqlite3_result_error_code(pCtx, rc);
197423 sqlite3_result_text(pCtx, res.z, res.n-1, sqlite3_free);
198312 sqlite3_context *pCtx; /* Function context - put error messages here */
198408 static void jsonInit(JsonString *p, sqlite3_context *pCtx){
198409 p->pCtx = pCtx;
198428 sqlite3_result_error_nomem(p->pCtx);
198573 sqlite3_result_error(p->pCtx, "JSON cannot hold BLOB values", -1);
198587 sqlite3_result_text64(p->pCtx, p->zBuf, p->nUsed,
198729 sqlite3_context *pCtx, /* Return value for this function */
198733 jsonInit(&s, pCtx);
198736 sqlite3_result_subtype(pCtx, JSON_SUBTYPE);
198775 sqlite3_context *pCtx, /* Return value for this function */
198781 sqlite3_result_null(pCtx);
198785 sqlite3_result_int(pCtx, 1);
198789 sqlite3_result_int(pCtx, 0);
198806 sqlite3_result_int64(pCtx, SMALLEST_INT64);
198816 sqlite3_result_int64(pCtx, i);
198832 sqlite3_result_double(pCtx, r);
198841 sqlite3_result_text(pCtx, pNode->u.zJContent, pNode->n,
198849 sqlite3_result_text(pCtx, pNode->u.zJContent+1, pNode->n-2,
198862 sqlite3_result_error_nomem(pCtx);
198918 sqlite3_result_text(pCtx, zOut, j, sqlite3_free);
198924 jsonReturnJson(pNode, pCtx, aReplace);
199172 sqlite3_context *pCtx, /* Report errors here */
199187 if( pCtx!=0 ){
199189 sqlite3_result_error_nomem(pCtx);
199191 sqlite3_result_error(pCtx, "malformed JSON", -1);
199257 sqlite3_context *pCtx,
199271 p = (JsonParse*)sqlite3_get_auxdata(pCtx, JSON_CACHE_ID+iKey);
199297 sqlite3_result_error_nomem(pCtx);
199309 sqlite3_set_auxdata(pCtx, JSON_CACHE_ID+iMinKey, p,
199311 return (JsonParse*)sqlite3_get_auxdata(pCtx, JSON_CACHE_ID+iMinKey);
199528 ** On an error, write an error message into pCtx and increment the
199538 sqlite3_context *pCtx /* Report errors here, if not NULL */
199555 assert( zErr!=0 && pCtx!=0 );
199558 sqlite3_result_error(pCtx, zMsg, -1);
199561 sqlite3_result_error_nomem(pCtx);
199572 sqlite3_context *pCtx,
199577 sqlite3_result_error(pCtx, zMsg, -1);
200219 pStr->pCtx = ctx;
200227 pStr->pCtx = ctx;
200324 pStr->pCtx = ctx;
205649 sqlite3_context *pCtx, /* Context for error messages */
205655 testcase( pCtx==0 );
205662 if( pCtx ) sqlite3_result_error_nomem(pCtx);
205672 if( pCtx ) sqlite3_result_error_nomem(pCtx);
207407 sqlite3_context *pCtx, /* SQLite scalar function context */
207414 sqlite3_result_error(pCtx, zBuf, -1);
207767 ** Collation sequence destructor function. The pCtx argument points to
207770 static void icuCollationDel(void *pCtx){
207771 UCollator *p = (UCollator *)pCtx;
207776 ** Collation sequence comparison function. The pCtx argument points to
207780 void *pCtx,
207787 UCollator *p = (UCollator *)pCtx;
209754 sqlite3_context *pCtx,
209758 sqlite3rbu *p = sqlite3_user_data(pCtx);
209767 sqlite3_result_text(pCtx, zIn, -1, SQLITE_STATIC);
209774 sqlite3_result_text(pCtx, &zIn[i+1], -1, SQLITE_STATIC);
210998 sqlite3_context *pCtx,
211002 sqlite3rbu *p = sqlite3_user_data(pCtx);
211023 sqlite3_result_error_code(pCtx, rc);
212688 sqlite3_context *pCtx,
212692 sqlite3rbu *p = (sqlite3rbu*)sqlite3_user_data(pCtx);
212705 sqlite3_result_error(pCtx, zErrmsg, -1);
212713 sqlite3_result_int(pCtx, nIndex);
212715 sqlite3_result_error(pCtx, sqlite3_errmsg(db), -1);
215547 void *pCtx;
215566 int (*xTableFilter)(void *pCtx, const char *zTab);
216041 assert( pTab->nCol==pSession->hook.xCount(pSession->hook.pCtx) );
216049 rc = pSession->hook.xNew(pSession->hook.pCtx, i, &pVal);
216051 rc = pSession->hook.xOld(pSession->hook.pCtx, i, &pVal);
216387 rc = pSession->hook.xNew(pSession->hook.pCtx, iCol, &pVal);
216390 rc = pSession->hook.xOld(pSession->hook.pCtx, iCol, &pVal);
216680 static int sessionStat1Old(void *pCtx, int iCol, sqlite3_value **ppVal){
216681 SessionStat1Ctx *p = (SessionStat1Ctx*)pCtx;
216683 int rc = p->hook.xOld(p->hook.pCtx, iCol, &pVal);
216690 static int sessionStat1New(void *pCtx, int iCol, sqlite3_value **ppVal){
216691 SessionStat1Ctx *p = (SessionStat1Ctx*)pCtx;
216693 int rc = p->hook.xNew(p->hook.pCtx, iCol, &pVal);
216700 static int sessionStat1Count(void *pCtx){
216701 SessionStat1Ctx *p = (SessionStat1Ctx*)pCtx;
216702 return p->hook.xCount(p->hook.pCtx);
216704 static int sessionStat1Depth(void *pCtx){
216705 SessionStat1Ctx *p = (SessionStat1Ctx*)pCtx;
216706 return p->hook.xDepth(p->hook.pCtx);
216721 pSession->hook.xNew(pSession->hook.pCtx, ii, &p);
216738 pSession->hook.xNew(pSession->hook.pCtx, ii, &p);
216832 if( pTab->nCol!=pSession->hook.xCount(pSession->hook.pCtx) ){
216846 pSession->hook.pCtx = (void*)&stat1;
216890 TESTONLY(int trc = ) pSession->hook.xOld(pSession->hook.pCtx, i, &p);
216893 TESTONLY(int trc = ) pSession->hook.xNew(pSession->hook.pCtx, i, &p);
216921 pSession->hook.xOld(pSession->hook.pCtx, i, &p);
216923 pSession->hook.xNew(pSession->hook.pCtx, i, &p);
216929 if( pSession->bIndirect || pSession->hook.xDepth(pSession->hook.pCtx) ){
216940 if( pSession->hook.xDepth(pSession->hook.pCtx)==0
217005 void *pCtx, /* Copy of third arg to preupdate_hook() */
217018 for(pSession=(sqlite3_session *)pCtx; pSession; pSession=pSession->pNext){
217042 static int sessionPreupdateOld(void *pCtx, int iVal, sqlite3_value **ppVal){
217043 return sqlite3_preupdate_old((sqlite3*)pCtx, iVal, ppVal);
217045 static int sessionPreupdateNew(void *pCtx, int iVal, sqlite3_value **ppVal){
217046 return sqlite3_preupdate_new((sqlite3*)pCtx, iVal, ppVal);
217048 static int sessionPreupdateCount(void *pCtx){
217049 return sqlite3_preupdate_count((sqlite3*)pCtx);
217051 static int sessionPreupdateDepth(void *pCtx){
217052 return sqlite3_preupdate_depth((sqlite3*)pCtx);
217062 pSession->hook.pCtx = (void*)pSession->db;
217078 static int sessionDiffOld(void *pCtx, int iVal, sqlite3_value **ppVal){
217079 SessionDiffCtx *p = (SessionDiffCtx*)pCtx;
217083 static int sessionDiffNew(void *pCtx, int iVal, sqlite3_value **ppVal){
217084 SessionDiffCtx *p = (SessionDiffCtx*)pCtx;
217088 static int sessionDiffCount(void *pCtx){
217089 SessionDiffCtx *p = (SessionDiffCtx*)pCtx;
217092 static int sessionDiffDepth(void *pCtx){
217104 pSession->hook.pCtx = (void*)pDiffCtx;
217198 SessionDiffCtx *pDiffCtx = (SessionDiffCtx*)pSession->hook.pCtx;
217237 SessionDiffCtx *pDiffCtx = (SessionDiffCtx*)pSession->hook.pCtx;
217444 void *pCtx /* First argument passed to xFilter */
217447 pSession->pFilterCtx = pCtx;
219824 void *pCtx, /* First argument for conflict handler */
219849 res = xConflict(pCtx, eType, pIter);
219862 res = xConflict(pCtx, eType+1, pIter);
219921 void *pCtx, /* First argument for the conflict handler */
219960 SQLITE_CHANGESET_DATA, p, pIter, xConflict, pCtx, pbRetry
219964 SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, 0
219999 SQLITE_CHANGESET_DATA, p, pIter, xConflict, pCtx, pbRetry
220005 SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, 0
220032 SQLITE_CHANGESET_CONFLICT, p, pIter, xConflict, pCtx, pbReplace
220055 void *pCtx /* First argument passed to xConflict */
220061 rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, &bReplace, &bRetry);
220072 rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, 0, 0);
220093 rc = sessionApplyOneOp(pIter, pApply, xConflict, pCtx, 0, 0);
220113 void *pCtx /* First argument passed to xConflict */
220137 rc = sessionApplyOneWithRetry(db, pIter2, pApply, xConflict, pCtx);
220167 void *pCtx, /* Copy of sixth arg to _apply() */
220171 void *pCtx, /* Copy of fifth arg to _apply() */
220175 void *pCtx, /* First argument passed to xConflict */
220210 db, pIter->bPatchset, zTab, &sApply, xConflict, pCtx
220234 schemaMismatch = (xFilter && (0==xFilter(pCtx, zNew)));
220301 rc = sessionApplyOneWithRetry(db, pIter, &sApply, xConflict, pCtx);
220312 rc = sessionRetryConstraints(db, bPatchset, zTab, &sApply, xConflict, pCtx);
220323 res = xConflict(pCtx, SQLITE_CHANGESET_FOREIGN_KEY, &sIter);
220366 void *pCtx, /* Copy of sixth arg to _apply() */
220370 void *pCtx, /* Copy of sixth arg to _apply() */
220374 void *pCtx, /* First argument passed to xConflict */
220383 db, pIter, xFilter, xConflict, pCtx, ppRebase, pnRebase, flags
220399 void *pCtx, /* Copy of sixth arg to _apply() */
220403 void *pCtx, /* Copy of fifth arg to _apply() */
220407 void *pCtx /* First argument passed to xConflict */
220410 db, nChangeset, pChangeset, xFilter, xConflict, pCtx, 0, 0, 0
220424 void *pCtx, /* Copy of sixth arg to _apply() */
220428 void *pCtx, /* Copy of sixth arg to _apply() */
220432 void *pCtx, /* First argument passed to xConflict */
220441 db, pIter, xFilter, xConflict, pCtx, ppRebase, pnRebase, flags
220451 void *pCtx, /* Copy of sixth arg to _apply() */
220455 void *pCtx, /* Copy of sixth arg to _apply() */
220459 void *pCtx /* First argument passed to xConflict */
220462 db, xInput, pIn, xFilter, xConflict, pCtx, 0, 0, 0
221397 sqlite3_context *pCtx, /* Context for returning result/error */
221629 void *pCtx, /* Context passed to xToken() */
221807 ** xToken(pCtx, 0, "i", 1, 0, 1);
221808 ** xToken(pCtx, 0, "won", 3, 2, 5);
221809 ** xToken(pCtx, 0, "first", 5, 6, 11);
221810 ** xToken(pCtx, FTS5_TOKEN_COLOCATED, "1st", 3, 6, 11);
221811 ** xToken(pCtx, 0, "place", 5, 12, 17);
221858 void *pCtx,
221862 void *pCtx, /* Copy of 2nd argument to xTokenize() */
222174 void *pCtx, /* Context passed to xToken() */
224488 sqlite3_context *pCtx, /* Context for returning result/error */
224498 sqlite3_result_error(pCtx, zErr, -1);
224519 sqlite3_result_text(pCtx, (const char*)ctx.zOut, -1, SQLITE_TRANSIENT);
224524 sqlite3_result_error_code(pCtx, rc);
224660 sqlite3_context *pCtx, /* Context for returning result/error */
224682 sqlite3_result_error(pCtx, zErr, -1);
224800 sqlite3_result_text(pCtx, (const char*)ctx.zOut, -1, SQLITE_TRANSIENT);
224802 sqlite3_result_error_code(pCtx, rc);
224919 sqlite3_context *pCtx, /* Context for returning result/error */
224966 sqlite3_result_double(pCtx, -1.0 * score);
224968 sqlite3_result_error_code(pCtx, rc);
226105 ** void *pCtx // Copy of 4th argument to sqlite3Fts5Tokenize()
226126 void *pCtx, /* Context passed to xToken() */
226131 pConfig->pTok, pCtx, flags, pText, nText, xToken
228042 TokenCtx *pCtx = (TokenCtx*)pContext;
228043 Fts5ExprPhrase *pPhrase = pCtx->pPhrase;
228048 if( pCtx->rc!=SQLITE_OK ) return pCtx->rc;
228077 pCtx->pPhrase = pPhrase = pNew;
228089 pCtx->rc = rc;
229013 sqlite3_context *pCtx, /* Function call context */
229018 Fts5Global *pGlobal = (Fts5Global*)sqlite3_user_data(pCtx);
229019 sqlite3 *db = sqlite3_context_db_handle(pCtx);
229036 sqlite3_result_error(pCtx, zErr, -1);
229049 sqlite3_result_error_nomem(pCtx);
229079 sqlite3_result_text(pCtx, zText, -1, SQLITE_TRANSIENT);
229086 sqlite3_result_error(pCtx, zErr, -1);
229089 sqlite3_result_error_code(pCtx, rc);
229098 sqlite3_context *pCtx, /* Function call context */
229102 fts5ExprFunction(pCtx, nArg, apVal, 0);
229105 sqlite3_context *pCtx, /* Function call context */
229109 fts5ExprFunction(pCtx, nArg, apVal, 1);
229118 sqlite3_context *pCtx, /* Function call context */
229125 sqlite3_result_error(pCtx,
229135 sqlite3_result_int(pCtx, aArr[sqlite3Fts5UnicodeCategory((u32)iCode)]);
229139 sqlite3_context *pCtx, /* Function call context */
229144 sqlite3_result_error(pCtx,
229152 sqlite3_result_int(pCtx, sqlite3Fts5UnicodeFold(iCode, bRemoveDiacritics));
229174 void *pCtx = (void*)pGlobal;
229178 rc = sqlite3_create_function(db, p->z, -1, SQLITE_UTF8, pCtx, p->x, 0, 0);
229284 void *pCtx, /* Copy of 2nd argument to xTokenize() */
229291 Fts5ExprCtx *p = (Fts5ExprCtx*)pCtx;
233054 PoslistOffsetsCtx *pCtx = (PoslistOffsetsCtx*)pContext;
233062 iVal += pCtx->iRead - 2;
233063 pCtx->iRead = iVal;
233064 if( fts5IndexColsetTest(pCtx->pColset, iVal) ){
233065 fts5BufferSafeAppendVarint(pCtx->pBuf, iVal + 2 - pCtx->iWrite);
233066 pCtx->iWrite = iVal;
233077 PoslistCallbackCtx *pCtx = (PoslistCallbackCtx*)pContext;
233086 if( pCtx->eState==2 ){
233089 if( fts5IndexColsetTest(pCtx->pColset, iCol) ){
233090 pCtx->eState = 1;
233091 fts5BufferSafeAppendVarint(pCtx->pBuf, 1);
233093 pCtx->eState = 0;
233102 if( pCtx->eState ){
233103 fts5BufferSafeAppendBlob(pCtx->pBuf, &pChunk[iStart], i-iStart);
233110 pCtx->eState = 2;
233113 pCtx->eState = fts5IndexColsetTest(pCtx->pColset, iCol);
233114 if( pCtx->eState ){
233115 fts5BufferSafeAppendBlob(pCtx->pBuf, &pChunk[iStart], i-iStart);
233127 void *pCtx, /* Context pointer for xChunk callback */
233145 xChunk(p, pCtx, pChunk, nChunk);
234282 void *pCtx,
234285 Fts5SegWriter *pWriter = (Fts5SegWriter*)pCtx;
236545 sqlite3_context *pCtx, /* Function call context */
236556 int eDetailNone = (sqlite3_user_data(pCtx)!=0);
236743 sqlite3_result_text(pCtx, (const char*)s.p, s.n, SQLITE_TRANSIENT);
236745 sqlite3_result_error_code(pCtx, rc);
236756 sqlite3_context *pCtx, /* Function call context */
236762 sqlite3_result_error(pCtx, "should be: fts5_rowid(subject, ....)", -1);
236769 sqlite3_result_error(pCtx,
236776 sqlite3_result_int64(pCtx, iRowid);
236779 sqlite3_result_error(pCtx,
238615 static void *fts5ApiUserData(Fts5Context *pCtx){
238616 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
238620 static int fts5ApiColumnCount(Fts5Context *pCtx){
238621 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
238626 Fts5Context *pCtx,
238630 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
238635 static int fts5ApiRowCount(Fts5Context *pCtx, i64 *pnRow){
238636 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
238642 Fts5Context *pCtx,
238647 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
238654 static int fts5ApiPhraseCount(Fts5Context *pCtx){
238655 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
238659 static int fts5ApiPhraseSize(Fts5Context *pCtx, int iPhrase){
238660 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
238665 Fts5Context *pCtx,
238671 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
238813 static int fts5ApiInstCount(Fts5Context *pCtx, int *pnInst){
238814 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
238824 Fts5Context *pCtx,
238830 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
238852 static sqlite3_int64 fts5ApiRowid(Fts5Context *pCtx){
238853 return fts5CursorRowid((Fts5Cursor*)pCtx);
238873 static int fts5ApiColumnSize(Fts5Context *pCtx, int iCol, int *pnToken){
238874 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
238897 rc = fts5ApiColumnText(pCtx, i, &z, &n);
238927 Fts5Context *pCtx, /* Fts5 context */
238931 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
238961 static void *fts5ApiGetAuxdata(Fts5Context *pCtx, int bClear){
238962 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
239004 Fts5Context *pCtx,
239009 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
239017 fts5ApiPhraseNext(pCtx, pIter, piCol, piOff);
239023 Fts5Context *pCtx,
239027 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
239053 Fts5Context *pCtx,
239059 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
239076 fts5ApiPhraseNextColumn(pCtx, pIter, piCol);
239129 Fts5Context *pCtx,
239134 Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
239242 static int fts5PoslistBlob(sqlite3_context *pCtx, Fts5Cursor *pCsr){
239291 sqlite3_result_blob(pCtx, val.p, val.n, sqlite3_free);
239301 sqlite3_context *pCtx, /* Context for sqlite3_result_xxx() calls */
239313 sqlite3_result_int64(pCtx, pCsr->iSpecial);
239322 sqlite3_result_int64(pCtx, pCsr->iCsrId);
239327 fts5PoslistBlob(pCtx, pCsr);
239333 fts5ApiInvoke(pCsr->pRank, pCsr, pCtx, pCsr->nRankArg, pCsr->apRankArg);
239340 sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pStmt, iCol+1));
239581 static void fts5ModuleDestroy(void *pCtx){
239584 Fts5Global *pGlobal = (Fts5Global*)pCtx;
239602 sqlite3_context *pCtx, /* Function call context */
239606 Fts5Global *pGlobal = (Fts5Global*)sqlite3_user_data(pCtx);
239618 sqlite3_context *pCtx, /* Function call context */
239624 sqlite3_result_text(pCtx, "fts5: 2022-12-28 14:03:47 df5c253c0b3dd24916e4ec7cf77d3db5294cc9fd45ae7b9c5e82ad8197f38a24", -1, SQLITE_TRANSIENT);
240132 Fts5InsertCtx *pCtx = (Fts5InsertCtx*)pContext;
240133 Fts5Index *pIdx = pCtx->pStorage->pIndex;
240136 if( (tflags & FTS5_TOKEN_COLOCATED)==0 || pCtx->szCol==0 ){
240137 pCtx->szCol++;
240139 return sqlite3Fts5IndexWrite(pIdx, pCtx->iCol, pCtx->szCol-1, pToken, nToken);
240581 Fts5IntegrityCtx *pCtx = (Fts5IntegrityCtx*)pContext;
240582 Fts5Termset *pTermset = pCtx->pTermset;
240592 if( (tflags & FTS5_TOKEN_COLOCATED)==0 || pCtx->szCol==0 ){
240593 pCtx->szCol++;
240596 switch( pCtx->pConfig->eDetail ){
240598 iPos = pCtx->szCol-1;
240599 iCol = pCtx->iCol;
240603 iPos = pCtx->iCol;
240608 assert( pCtx->pConfig->eDetail==FTS5_DETAIL_NONE );
240616 pCtx->cksum ^= sqlite3Fts5IndexEntryCksum(
240617 pCtx->iRowid, iCol, iPos, 0, pToken, nToken
240621 for(ii=0; rc==SQLITE_OK && ii<pCtx->pConfig->nPrefix; ii++){
240622 const int nChar = pCtx->pConfig->aPrefix[ii];
240627 pCtx->cksum ^= sqlite3Fts5IndexEntryCksum(
240628 pCtx->iRowid, iCol, iPos, ii+1, pToken, nByte
241043 void *pCtx,
241089 rc = xToken(pCtx, 0, pFold, nByte, is, ie);
241364 void *pCtx,
241458 rc = xToken(pCtx, 0, aFold, zOut-aFold, is, ie);
241498 void *pCtx,
241502 fts5_api *pApi = (fts5_api*)pCtx;
241535 void *pCtx;
242100 void *pCtx,
242107 PorterContext *p = (PorterContext*)pCtx;
242159 return p->xToken(p->pCtx, tflags, aBuf, nBuf, iStart, iEnd);
242162 return p->xToken(p->pCtx, tflags, pToken, nToken, iStart, iEnd);
242170 void *pCtx,
242178 sCtx.pCtx = pCtx;
242243 void *pCtx,
242282 rc = xToken(pCtx, 0, aBuf, zOut-aBuf, iStart, iStart + zOut-aBuf);
244146 sqlite3_context *pCtx, /* Context for sqlite3_result_xxx() calls */
244156 pCtx, (const char*)pCsr->term.p, pCsr->term.n, SQLITE_TRANSIENT
244163 sqlite3_result_text(pCtx, z, -1, SQLITE_STATIC);
244181 sqlite3_result_int64(pCtx, pCsr->pIter->iRowid);
244192 sqlite3_result_text(pCtx, z, -1, SQLITE_STATIC);
244200 sqlite3_result_int(pCtx, ii);
244207 if( iVal>0 ) sqlite3_result_int64(pCtx, iVal);
245638 CodecContext *pCtx = (CodecContext *)ctx;
245649 int cipherPageSize = pCtx->readCtx->codecConst.cipherPageSize;
245655 memcpyRc = memcpy_s(pCtx->buffer, cipherPageSize, SQLITE_FILE_HEADER, FILE_HEADER_SIZE);
245657 sqlite3CodecSetError(pCtx, SQLITE_ERROR);
245661 rc = sqlite3CodecDecryptData(pCtx, OPERATE_CONTEXT_READ, pgno, cipherPageSize - offset, (unsigned char *)(pData + offset), pCtx->buffer + offset);
245663 sqlite3CodecSetError(pCtx, rc);
245665 (void)memcpy_s(pData, cipherPageSize, pCtx->buffer, cipherPageSize);
245670 memcpyRc = memcpy_s(pCtx->buffer, cipherPageSize, pCtx->salt, FILE_HEADER_SIZE);
245672 sqlite3CodecSetError(pCtx, SQLITE_ERROR);
245676 rc = sqlite3CodecEncryptData(pCtx, OPERATE_CONTEXT_WRITE, pgno, cipherPageSize - offset, (unsigned char *)(pData + offset), pCtx->buffer + offset);
245678 sqlite3CodecSetError(pCtx, rc);
245681 return pCtx->buffer;
245685 memcpyRc = memcpy_s(pCtx->buffer, cipherPageSize, pCtx->salt, FILE_HEADER_SIZE);
245687 sqlite3CodecSetError(pCtx, SQLITE_ERROR);
245691 rc = sqlite3CodecEncryptData(pCtx, OPERATE_CONTEXT_READ, pgno, cipherPageSize - offset, (unsigned char *)(pData + offset), pCtx->buffer + offset);
245693 sqlite3CodecSetError(pCtx, rc);
245696 return pCtx->buffer;