Lines Matching refs:pVal
10668 SQLITE_API int sqlite3_vtab_in_first(sqlite3_value *pVal, sqlite3_value **ppOut);
10669 SQLITE_API int sqlite3_vtab_in_next(sqlite3_value *pVal, sqlite3_value **ppOut);
20958 SQLITE_PRIVATE void sqlite3MultiValuesEnd(Parse *pParse, Select *pVal);
85162 static SQLITE_NOINLINE const void *valueToText(sqlite3_value* pVal, u8 enc){
85163 assert( pVal!=0 );
85164 assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
85166 assert( !sqlite3VdbeMemIsRowSet(pVal) );
85167 assert( (pVal->flags & (MEM_Null))==0 );
85168 if( pVal->flags & (MEM_Blob|MEM_Str) ){
85169 if( ExpandBlob(pVal) ) return 0;
85170 pVal->flags |= MEM_Str;
85171 if( pVal->enc != (enc & ~SQLITE_UTF16_ALIGNED) ){
85172 sqlite3VdbeChangeEncoding(pVal, enc & ~SQLITE_UTF16_ALIGNED);
85174 if( (enc & SQLITE_UTF16_ALIGNED)!=0 && 1==(1&SQLITE_PTR_TO_INT(pVal->z)) ){
85175 assert( (pVal->flags & (MEM_Ephem|MEM_Static))!=0 );
85176 if( sqlite3VdbeMemMakeWriteable(pVal)!=SQLITE_OK ){
85180 sqlite3VdbeMemNulTerminate(pVal); /* IMP: R-31275-44060 */
85182 sqlite3VdbeMemStringify(pVal, enc, 0);
85183 assert( 0==(1&SQLITE_PTR_TO_INT(pVal->z)) );
85185 assert(pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) || pVal->db==0
85186 || pVal->db->mallocFailed );
85187 if( pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) ){
85188 assert( sqlite3VdbeMemValidStrRep(pVal) );
85189 return pVal->z;
85205 SQLITE_PRIVATE const void *sqlite3ValueText(sqlite3_value* pVal, u8 enc){
85206 if( !pVal ) return 0;
85207 assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
85209 assert( !sqlite3VdbeMemIsRowSet(pVal) );
85210 if( (pVal->flags&(MEM_Str|MEM_Term))==(MEM_Str|MEM_Term) && pVal->enc==enc ){
85211 assert( sqlite3VdbeMemValidStrRep(pVal) );
85212 return pVal->z;
85214 if( pVal->flags&MEM_Null ){
85217 return valueToText(pVal, enc);
85226 SQLITE_PRIVATE int sqlite3ValueIsOfClass(const sqlite3_value *pVal, void(*xFree)(void*)){
85227 if( ALWAYS(pVal!=0)
85228 && ALWAYS((pVal->flags & (MEM_Str|MEM_Blob))!=0)
85229 && (pVal->flags & MEM_Dyn)!=0
85230 && pVal->xDel==xFree
85347 sqlite3_value *pVal = 0; /* New value */ local
85382 pVal = valueNew(db, pCtx);
85383 if( pVal==0 ){
85389 ctx.pOut = pVal;
85395 sqlite3ErrorMsg(pCtx->pParse, "%s", sqlite3_value_text(pVal));
85397 sqlite3ValueApplyAffinity(pVal, aff, SQLITE_UTF8);
85399 rc = sqlite3VdbeChangeEncoding(pVal, enc);
85400 if( NEVER(rc==SQLITE_OK && sqlite3VdbeMemTooBig(pVal)) ){
85408 pVal = 0;
85418 *ppVal = pVal;
85445 sqlite3_value *pVal = 0; local
85498 pVal = valueNew(db, pCtx);
85499 if( pVal==0 ) goto no_mem;
85501 sqlite3VdbeMemSetInt64(pVal, (i64)pExpr->u.iValue*negInt);
85505 sqlite3VdbeMemSetInt64(pVal, iVal*negInt);
85509 sqlite3ValueSetStr(pVal, -1, zVal, SQLITE_UTF8, SQLITE_DYNAMIC);
85514 assert( pVal && pVal->z && pVal->flags==(MEM_Str|MEM_Term) );
85515 sqlite3AtoF(pVal->z, &pVal->u.r, pVal->n, SQLITE_UTF8);
85516 pVal->flags = MEM_Real;
85521 sqlite3ValueApplyAffinity(pVal, SQLITE_AFF_NUMERIC, SQLITE_UTF8);
85524 sqlite3ValueApplyAffinity(pVal, affinity, SQLITE_UTF8);
85526 assert( (pVal->flags & MEM_IntReal)==0 );
85527 if( pVal->flags & (MEM_Int|MEM_IntReal|MEM_Real) ){
85528 testcase( pVal->flags & MEM_Int );
85529 testcase( pVal->flags & MEM_Real );
85530 pVal->flags &= ~MEM_Str;
85533 rc = sqlite3VdbeChangeEncoding(pVal, enc);
85537 if( SQLITE_OK==valueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal,pCtx)
85538 && pVal!=0
85540 sqlite3VdbeMemNumerify(pVal);
85541 if( pVal->flags & MEM_Real ){
85542 pVal->u.r = -pVal->u.r;
85543 }else if( pVal->u.i==SMALLEST_INT64 ){
85545 pVal->u.r = -(double)SMALLEST_INT64;
85547 pVal->u.r = LARGEST_INT64;
85549 MemSetTypeFlag(pVal, MEM_Real);
85551 pVal->u.i = -pVal->u.i;
85553 sqlite3ValueApplyAffinity(pVal, affinity, enc);
85556 pVal = valueNew(db, pCtx);
85557 if( pVal==0 ) goto no_mem;
85558 sqlite3VdbeMemSetNull(pVal);
85566 pVal = valueNew(db, pCtx);
85567 if( !pVal ) goto no_mem;
85571 sqlite3VdbeMemSetStr(pVal, sqlite3HexToBlob(db, zVal, nVal), nVal/2,
85577 rc = valueFromFunction(db, pExpr, enc, affinity, &pVal, pCtx);
85582 pVal = valueNew(db, pCtx);
85583 if( pVal ){
85584 pVal->flags = MEM_Int;
85585 pVal->u.i = pExpr->u.zToken[4]==0;
85586 sqlite3ValueApplyAffinity(pVal, affinity, enc);
85590 *ppVal = pVal;
85601 if( pCtx==0 ) sqlite3ValueFree(pVal);
85603 assert( pCtx==0 ); sqlite3ValueFree(pVal);
85655 sqlite3_value *pVal = 0; local
85663 pVal = valueNew(db, pAlloc);
85664 if( pVal ){
85665 sqlite3VdbeMemSetNull((Mem*)pVal);
85672 pVal = valueNew(db, pAlloc);
85673 if( pVal ){
85674 rc = sqlite3VdbeMemCopy((Mem*)pVal, &v->aVar[iBindVar-1]);
85675 sqlite3ValueApplyAffinity(pVal, affinity, ENC(db));
85676 pVal->db = pParse->db;
85680 rc = valueFromExpr(db, pExpr, ENC(db), affinity, &pVal, pAlloc);
85683 assert( pVal==0 || pVal->db==db );
85684 *ppVal = pVal;
85743 sqlite3_value *pVal = 0; local
85747 rc = stat4ValueFromExpr(pParse, pElem, aff, &alloc, &pVal);
85748 if( !pVal ) break;
85871 static SQLITE_NOINLINE int valueBytes(sqlite3_value *pVal, u8 enc){
85872 return valueToText(pVal, enc)!=0 ? pVal->n : 0;
85874 SQLITE_PRIVATE int sqlite3ValueBytes(sqlite3_value *pVal, u8 enc){
85875 Mem *p = (Mem*)pVal;
85877 if( (p->flags & MEM_Str)!=0 && pVal->enc==enc ){
85880 if( (p->flags & MEM_Str)!=0 && enc!=SQLITE_UTF8 && pVal->enc!=SQLITE_UTF8 ){
85891 return valueBytes(pVal, enc);
91642 SQLITE_API const void *sqlite3_value_blob(sqlite3_value *pVal){
91643 Mem *p = (Mem*)pVal;
91652 return sqlite3_value_text(pVal);
91655 SQLITE_API int sqlite3_value_bytes(sqlite3_value *pVal){
91656 return sqlite3ValueBytes(pVal, SQLITE_UTF8);
91658 SQLITE_API int sqlite3_value_bytes16(sqlite3_value *pVal){
91659 return sqlite3ValueBytes(pVal, SQLITE_UTF16NATIVE);
91661 SQLITE_API double sqlite3_value_double(sqlite3_value *pVal){
91662 return sqlite3VdbeRealValue((Mem*)pVal);
91664 SQLITE_API int sqlite3_value_int(sqlite3_value *pVal){
91665 return (int)sqlite3VdbeIntValue((Mem*)pVal);
91667 SQLITE_API sqlite_int64 sqlite3_value_int64(sqlite3_value *pVal){
91668 return sqlite3VdbeIntValue((Mem*)pVal);
91670 SQLITE_API unsigned int sqlite3_value_subtype(sqlite3_value *pVal){
91671 Mem *pMem = (Mem*)pVal;
91674 SQLITE_API void *sqlite3_value_pointer(sqlite3_value *pVal, const char *zPType){
91675 Mem *p = (Mem*)pVal;
91687 SQLITE_API const unsigned char *sqlite3_value_text(sqlite3_value *pVal){
91688 return (const unsigned char *)sqlite3ValueText(pVal, SQLITE_UTF8);
91691 SQLITE_API const void *sqlite3_value_text16(sqlite3_value* pVal){
91692 return sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);
91694 SQLITE_API const void *sqlite3_value_text16be(sqlite3_value *pVal){
91695 return sqlite3ValueText(pVal, SQLITE_UTF16BE);
91697 SQLITE_API const void *sqlite3_value_text16le(sqlite3_value *pVal){
91698 return sqlite3ValueText(pVal, SQLITE_UTF16LE);
91705 SQLITE_API int sqlite3_value_type(sqlite3_value* pVal){
91775 if( pVal->flags & MEM_Null ){
91777 }else if( pVal->flags & (MEM_Real|MEM_IntReal) ){
91779 }else if( pVal->flags & MEM_Int ){
91781 }else if( pVal->flags & MEM_Str ){
91784 assert( eType == aType[pVal->flags&MEM_AffMask] );
91787 return aType[pVal->flags&MEM_AffMask];
91789 SQLITE_API int sqlite3_value_encoding(sqlite3_value *pVal){
91790 return pVal->enc;
91794 SQLITE_API int sqlite3_value_nochange(sqlite3_value *pVal){
91795 return (pVal->flags&(MEM_Null|MEM_Zero))==(MEM_Null|MEM_Zero);
91799 SQLITE_API int sqlite3_value_frombind(sqlite3_value *pVal){
91800 return (pVal->flags&MEM_FromBind)!=0;
92475 sqlite3_value *pVal, /* Pointer to the ValueList object */
92483 if( pVal==0 ) return SQLITE_MISUSE_BKPT;
92484 if( (pVal->flags & MEM_Dyn)==0 || pVal->xDel!=sqlite3VdbeValueListFree ){
92487 assert( (pVal->flags&(MEM_TypeMask|MEM_Term|MEM_Subtype)) ==
92489 assert( pVal->eSubtype=='p' );
92490 assert( pVal->u.zPType!=0 && strcmp(pVal->u.zPType,"ValueList")==0 );
92491 pRhs = (ValueList*)pVal->z;
92529 SQLITE_API int sqlite3_vtab_in_first(sqlite3_value *pVal, sqlite3_value **ppOut){
92530 return valueFromValueList(pVal, ppOut, 0);
92537 SQLITE_API int sqlite3_vtab_in_next(sqlite3_value *pVal, sqlite3_value **ppOut){
92538 return valueFromValueList(pVal, ppOut, 1);
93703 sqlite3_value *pVal = 0; local
93707 rc = sqlite3ValueFromExpr(db, pDflt, ENC(db), pCol->affinity, &pVal);
93708 if( rc==SQLITE_OK && pVal==0 ){
93711 p->apDflt[iIdx] = pVal;
94777 SQLITE_API int sqlite3_value_numeric_type(sqlite3_value *pVal){
94778 int eType = sqlite3_value_type(pVal);
94780 Mem *pMem = (Mem*)pVal;
94782 eType = sqlite3_value_type(pVal);
94792 sqlite3_value *pVal,
94796 applyAffinity((Mem *)pVal, affinity, enc);
105878 Mem *pVal /* Memory cell containing record */
105890 getVarint32NR((const u8*)&pVal->z[1], t);
105917 nReq = pVal->n + sizeof(SorterRecord);
105918 nPMA = pVal->n + sqlite3VarintLen(pVal->n);
105976 memcpy(SRVAL(pNew), pVal->z, pVal->n);
105977 pNew->nVal = pVal->n;
106843 Mem *pVal, /* Value to compare to current sorter key */
106873 *pRes = sqlite3VdbeRecordCompare(pVal->n, pVal->z, r2);
113182 sqlite3_value *pVal;
113187 pVal = sqlite3VdbeGetBoundValue(pParse->pReprepare, p->iColumn,
113189 if( pVal ){
113190 if( sqlite3_value_type(pVal)==SQLITE_INTEGER ){
113191 sqlite3_int64 vv = sqlite3_value_int64(pVal);
113197 sqlite3ValueFree(pVal);
118155 sqlite3_value *pVal = 0;
118157 rc = sqlite3ValueFromExpr(db, pDflt, SQLITE_UTF8, SQLITE_AFF_BLOB, &pVal);
118163 if( !pVal ){
118167 sqlite3ValueFree(pVal);
131536 static int isNHex(const char *z, int N, u32 *pVal){
131543 *pVal = v;
135399 SQLITE_PRIVATE void sqlite3MultiValuesEnd(Parse *pParse, Select *pVal){
135400 if( ALWAYS(pVal) && pVal->pSrc->nSrc>0 ){
135401 SrcItem *pItem = &pVal->pSrc->a[0];
162735 sqlite3_value *pVal = 0;
162754 pVal = sqlite3VdbeGetBoundValue(pReprepare, iCol, SQLITE_AFF_BLOB);
162755 if( pVal && sqlite3_value_type(pVal)==SQLITE_TEXT ){
162756 z = sqlite3_value_text(pVal);
162851 sqlite3ValueFree(pVal);
162883 sqlite3ValueFree(pVal);
164166 Expr *pVal = sqlite3Expr(db, TK_INTEGER, 0);
164167 if( pVal==0 ) return;
164168 ExprSetProperty(pVal, EP_IntValue);
164169 pVal->u.iValue = iVal;
164170 pNew = sqlite3PExpr(pParse, TK_MATCH, 0, pVal);
164172 Expr *pVal = sqlite3Expr(db, TK_REGISTER, 0);
164173 if( pVal==0 ) return;
164174 pVal->iTable = iReg;
164175 pNew = sqlite3PExpr(pParse, TK_MATCH, 0, pVal);
166458 sqlite3_value *pVal = 0; /* Value extracted from record */
166474 rc = sqlite3Stat4Column(db, p->aSample[i].p, p->aSample[i].n, nEq, &pVal);
166476 int res = sqlite3MemCompare(p1, pVal, pColl);
166480 int res = sqlite3MemCompare(p2, pVal, pColl);
166506 sqlite3ValueFree(pVal);
168957 sqlite3_value *pVal = 0;
168972 pVal = pH->aRhs[iCons];
168974 *ppVal = pVal;
168976 if( rc==SQLITE_OK && pVal==0 ){ /* IMP: R-19933-32160 */
172635 sqlite3_value *pVal;
172651 sqlite3_value_free(p->pVal);
172652 p->pVal = sqlite3_value_dup(apArg[0]);
172653 if( p->pVal==0 ){
172672 sqlite3_value_free(p->pVal);
172673 p->pVal = 0;
172680 if( p && p->pVal ){
172681 sqlite3_result_value(pCtx, p->pVal);
172687 if( p && p->pVal ){
172688 sqlite3_result_value(pCtx, p->pVal);
172689 sqlite3_value_free(p->pVal);
172690 p->pVal = 0;
174596 sqlite3_value *pVal = 0;
174597 sqlite3ValueFromExpr(db, pExpr, db->enc, SQLITE_AFF_NUMERIC, &pVal);
174598 if( pVal && sqlite3_value_int(pVal)>0 ){
174601 sqlite3ValueFree(pVal);
182521 sqlite3_value *pVal;
182529 pVal = sqlite3ValueNew(0);
182530 sqlite3ValueSetStr(pVal, -1, zSql, SQLITE_UTF16NATIVE, SQLITE_STATIC);
182531 zSql8 = sqlite3ValueText(pVal, SQLITE_UTF8);
182537 sqlite3ValueFree(pVal);
183382 int *pVal = va_arg(ap,int*);
183384 if( 0==*pVal ) sqlite3GlobalConfig.mNoVisibleRowid = TF_NoVisibleRowid;
183385 if( 1==*pVal ) sqlite3GlobalConfig.mNoVisibleRowid = 0;
183386 *pVal = (sqlite3GlobalConfig.mNoVisibleRowid==0);
183388 *pVal = 0;
186302 sqlite3_value *pVal;
186314 pVal = sqlite3ValueNew(0);
186315 sqlite3ValueSetStr(pVal, -1, zFilename, SQLITE_UTF16NATIVE, SQLITE_STATIC);
186316 zFilename8 = sqlite3ValueText(pVal, SQLITE_UTF8);
186327 sqlite3ValueFree(pVal);
189568 static void fts3GetDeltaVarint(char **pp, sqlite3_int64 *pVal){
189571 *pVal += iVal;
189586 sqlite3_int64 *pVal
189599 *pVal = iVal;
191591 sqlite3_int64 *pVal /* IN/OUT: Integer value */
191599 *pVal = (i64)((u64)*pVal - iVal);
191601 *pVal = (i64)((u64)*pVal + iVal);
192353 static sqlite3_int64 fts3DocidRange(sqlite3_value *pVal, i64 iDefault){
192354 if( pVal ){
192355 int eType = sqlite3_value_numeric_type(pVal);
192357 return sqlite3_value_int64(pVal);
192768 sqlite3_value *pVal, /* argv[0] passed to function */
192772 *ppCsr = (Fts3Cursor*)sqlite3_value_pointer(pVal, "fts3cursor");
204871 static int fts3SpecialInsert(Fts3Table *p, sqlite3_value *pVal){
204873 const char *zVal = (const char *)sqlite3_value_text(pVal);
204874 int nVal = sqlite3_value_bytes(pVal);
217920 static int geopolyParseNumber(GeoParse *p, GeoCoord *pVal){
217955 if( pVal ){
217961 *pVal = r;
217963 *pVal = (GeoCoord)atof((const char*)p->z);
218057 sqlite3_value *pVal, /* The value to decode */
218063 if( sqlite3_value_type(pVal)==SQLITE_BLOB
218064 && (nByte = sqlite3_value_bytes(pVal))>=(int)(4+6*sizeof(GeoCoord))
218066 const unsigned char *a = sqlite3_value_blob(pVal);
218096 }else if( sqlite3_value_type(pVal)==SQLITE_TEXT ){
218097 const unsigned char *zJson = sqlite3_value_text(pVal);
224657 sqlite3_value *pVal;
224698 pVal = sqlite3_column_value(pIter->pSelect, i);
224699 p->rc = sqlite3_bind_value(pWriter, i+1, pVal);
224717 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
224718 p->rc = sqlite3_bind_value(pWriter, pIter->nCol+1, pVal);
224764 sqlite3_value *pVal;
224773 pVal = sqlite3_column_value(pIter->pSelect, i);
224775 p->rc = sqlite3_bind_value(pUpdate, i+1, pVal);
224783 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
224784 p->rc = sqlite3_bind_value(pUpdate, pIter->nCol+1, pVal);
228695 sqlite3_value *pVal;
228699 rc = pSession->hook.xNew(pSession->hook.pCtx, iIdx, &pVal);
228701 rc = pSession->hook.xOld(pSession->hook.pCtx, iIdx, &pVal);
228705 eType = sqlite3_value_type(pVal);
228710 iVal = sqlite3_value_int64(pVal);
228712 double rVal = sqlite3_value_double(pVal);
228721 z = (const u8 *)sqlite3_value_text(pVal);
228723 z = (const u8 *)sqlite3_value_blob(pVal);
228725 n = sqlite3_value_bytes(pVal);
229035 sqlite3_value *pVal; /* Value returned by preupdate_new/old */
229047 rc = pSession->hook.xNew(pSession->hook.pCtx, iIdx, &pVal);
229050 rc = pSession->hook.xOld(pSession->hook.pCtx, iIdx, &pVal);
229054 if( sqlite3_value_type(pVal)!=eType ) return 0;
229065 if( sqlite3_value_int64(pVal)!=iVal ) return 0;
229070 if( sqlite3_value_double(pVal)!=rVal ) return 0;
229076 if( sqlite3_value_bytes(pVal)!=n ) return 0;
229078 z = sqlite3_value_text(pVal);
229080 z = sqlite3_value_blob(pVal);
229700 sqlite3_value *pVal = 0;
229701 int rc = p->hook.xOld(p->hook.pCtx, iCol, &pVal);
229702 if( rc==SQLITE_OK && iCol==1 && sqlite3_value_type(pVal)==SQLITE_NULL ){
229703 pVal = p->pSession->pZeroBlob;
229705 *ppVal = pVal;
229710 sqlite3_value *pVal = 0;
229711 int rc = p->hook.xNew(p->hook.pCtx, iCol, &pVal);
229712 if( rc==SQLITE_OK && iCol==1 && sqlite3_value_type(pVal)==SQLITE_NULL ){
229713 pVal = p->pSession->pZeroBlob;
229715 *ppVal = pVal;
230627 static void sessionAppendValue(SessionBuffer *p, sqlite3_value *pVal, int *pRc){
230631 rc = sessionSerializeValue(0, pVal, &nByte);
230634 rc = sessionSerializeValue(&p->aBuf[p->nBuf], pVal, 0);
231609 sqlite3_value *pVal, /* Set the value of this object */
231621 sqlite3ValueSetStr(pVal, nData, (char*)aCopy, enc, sqlite3_free);
232310 sqlite3_value *pVal = apVal[iCol + (abPK[iCol] ? 0 : nCol)];
232311 sessionAppendValue(&sOut, pVal, &rc);
232318 sqlite3_value *pVal = (abPK[iCol] ? 0 : apVal[iCol]);
232319 sessionAppendValue(&sOut, pVal, &rc);
232763 sqlite3_value *pVal /* Value to bind */
232765 int eType = sqlite3_value_type(pVal);
232770 if( (eType==SQLITE_TEXT || eType==SQLITE_BLOB) && pVal->z==0 ){
232776 return sqlite3_bind_value(pStmt, i, pVal);
232811 sqlite3_value *pVal = 0;
232812 (void)xValue(pIter, i, &pVal);
232813 if( pVal==0 ){
232818 rc = sessionBindValue(pStmt, i+1, pVal);
232863 sqlite3_value *pVal = 0;
232864 sqlite3changeset_new(pIter, ii, &pVal);
232865 sqlite3_bind_int(pSelect, ii+1+nCol, (pVal==0));
232866 if( pVal ) rc = sessionBindValue(pSelect, ii+1, pVal);
232916 sqlite3_value *pVal = 0;
232918 sqlite3changeset_old(pIter, i, &pVal);
232920 sqlite3changeset_new(pIter, i, &pVal);
232922 sessionAppendValue(&p->rebase, pVal, &rc);
236209 static int sqlite3Fts5IsLocaleValue(Fts5Config *pConfig, sqlite3_value *pVal);
236210 static int sqlite3Fts5DecodeLocaleValue(sqlite3_value *pVal,
238433 static const char *fts5ValueToText(sqlite3_value *pVal){
238434 const char *zRet = (const char*)sqlite3_value_text(pVal);
240180 sqlite3_value *pVal,
240187 if( SQLITE_INTEGER==sqlite3_value_numeric_type(pVal) ){
240188 pgsz = sqlite3_value_int(pVal);
240199 if( SQLITE_INTEGER==sqlite3_value_numeric_type(pVal) ){
240200 nHashSize = sqlite3_value_int(pVal);
240211 if( SQLITE_INTEGER==sqlite3_value_numeric_type(pVal) ){
240212 nAutomerge = sqlite3_value_int(pVal);
240224 if( SQLITE_INTEGER==sqlite3_value_numeric_type(pVal) ){
240225 nUsermerge = sqlite3_value_int(pVal);
240236 if( SQLITE_INTEGER==sqlite3_value_numeric_type(pVal) ){
240237 nCrisisMerge = sqlite3_value_int(pVal);
240250 if( SQLITE_INTEGER==sqlite3_value_numeric_type(pVal) ){
240251 nVal = sqlite3_value_int(pVal);
240261 const char *zIn = (const char*)sqlite3_value_text(pVal);
240278 if( SQLITE_INTEGER==sqlite3_value_numeric_type(pVal) ){
240279 bVal = sqlite3_value_int(pVal);
240290 if( SQLITE_INTEGER==sqlite3_value_numeric_type(pVal) ){
240291 bVal = sqlite3_value_int(pVal);
240333 sqlite3_value *pVal = sqlite3_column_value(p, 1);
240335 iVersion = sqlite3_value_int(pVal);
240338 sqlite3Fts5ConfigSetValue(pConfig, zK, pVal, &bDummy);
254974 static i64 fts5GetRowidLimit(sqlite3_value *pVal, i64 iDefault){
254975 if( pVal ){
254976 int eType = sqlite3_value_numeric_type(pVal);
254978 return sqlite3_value_int64(pVal);
255022 static int sqlite3Fts5IsLocaleValue(Fts5Config *pConfig, sqlite3_value *pVal){
255024 if( sqlite3_value_type(pVal)==SQLITE_BLOB ){
255031 const u8 *pBlob = sqlite3_value_blob(pVal);
255032 int nBlob = sqlite3_value_bytes(pVal);
255056 sqlite3_value *pVal,
255062 const char *p = sqlite3_value_blob(pVal);
255063 int n = sqlite3_value_bytes(pVal);
255066 assert( sqlite3_value_type(pVal)==SQLITE_BLOB );
255097 sqlite3_value *pVal, /* Value to extract expression text from */
255103 if( sqlite3Fts5IsLocaleValue(pConfig, pVal) ){
255108 rc = sqlite3Fts5DecodeLocaleValue(pVal, &pText, &nText, &pLoc, &nLoc);
255115 *pzText = (char*)sqlite3_value_text(pVal);
255454 sqlite3_value *pVal /* Value inserted into rank column */
255485 int nMerge = sqlite3_value_int(pVal);
255488 int iArg = sqlite3_value_int(pVal);
255492 pConfig->bPrefixIndex = sqlite3_value_int(pVal);
255502 rc = sqlite3Fts5ConfigSetValue(pTab->p.pConfig, zCmd, pVal, &bError);
255508 rc = sqlite3Fts5StorageConfigValue(pTab->pStorage, zCmd, pVal, 0);
255719 sqlite3_value *pVal = apVal[ii+2];
255720 if( sqlite3Fts5IsLocaleValue(pConfig, pVal) ){
255940 sqlite3_value *pVal = sqlite3_column_value(pStmt, iCol+1);
255947 && sqlite3Fts5IsLocaleValue(pConfig, pVal)
255949 rc = sqlite3Fts5DecodeLocaleValue(pVal, ppText, pnText, &pLoc, &nLoc);
255951 *ppText = (const char*)sqlite3_value_text(pVal);
255952 *pnText = sqlite3_value_bytes(pVal);
256771 sqlite3_value *pVal = sqlite3_column_value(pCsr->pStmt, iCol+1);
256774 && sqlite3Fts5IsLocaleValue(pConfig, pVal)
256784 sqlite3_result_value(pCtx, pVal);
258124 sqlite3_value *pVal = 0;
258134 pVal = sqlite3_column_value(pSeek, iCol);
258136 pVal = apVal[iCol-1];
258139 if( pConfig->bLocale && sqlite3Fts5IsLocaleValue(pConfig, pVal) ){
258140 rc = sqlite3Fts5DecodeLocaleValue(pVal, &pText, &nText, &pLoc, &nLoc);
258142 if( sqlite3_value_type(pVal)!=SQLITE_TEXT ){
258146 pFree = pVal = sqlite3_value_dup(pVal);
258147 if( pVal==0 ){
258152 pText = (const char*)sqlite3_value_text(pVal);
258153 nText = sqlite3_value_bytes(pVal);
258451 sqlite3_value *pVal = sqlite3_column_value(pScan, ctx.iCol+1);
258453 && sqlite3Fts5IsLocaleValue(pConfig, pVal)
258455 rc = sqlite3Fts5DecodeLocaleValue(pVal, &pText, &nText, &pLoc, &nLoc);
258457 pText = (const char*)sqlite3_value_text(pVal);
258458 nText = sqlite3_value_bytes(pVal);
258574 sqlite3_value *pVal = apVal[i];
258576 if( sqlite3_value_nochange(pVal) && p->pSavedRow ){
258579 pVal = sqlite3_column_value(p->pSavedRow, i-1);
258585 }else if( sqlite3Fts5IsLocaleValue(pConfig, pVal) ){
258592 rc = sqlite3Fts5DecodeLocaleValue(pVal, &pText, &nText, &pLoc, &nLoc);
258604 rc = sqlite3_bind_value(pInsert, i, pVal);
258645 sqlite3_value *pVal = apVal[ctx.iCol+2];
258646 if( p->pSavedRow && sqlite3_value_nochange(pVal) ){
258647 pVal = sqlite3_column_value(p->pSavedRow, ctx.iCol+1);
258654 pVal = apVal[ctx.iCol+2];
258657 if( pConfig->bLocale && sqlite3Fts5IsLocaleValue(pConfig, pVal) ){
258658 rc = sqlite3Fts5DecodeLocaleValue(pVal, &pText, &nText, &pLoc, &nLoc);
258660 pText = (const char*)sqlite3_value_text(pVal);
258661 nText = sqlite3_value_bytes(pVal);
258840 sqlite3_value *pVal = sqlite3_column_value(pScan, i+1);
258843 && sqlite3Fts5IsLocaleValue(pConfig, pVal)
258846 pVal, &pText, &nText, &pLoc, &nLoc
258854 pText = (const char*)sqlite3_value_text(pVal);
258855 nText = sqlite3_value_bytes(pVal);
259089 sqlite3_value *pVal,
259096 if( pVal ){
259097 sqlite3_bind_value(pReplace, 2, pVal);
259105 if( rc==SQLITE_OK && pVal ){