Lines Matching defs:pVal
77696 ** The pVal argument is known to be a value other than NULL.
77700 static SQLITE_NOINLINE const void *valueToText(sqlite3_value* pVal, u8 enc){
77701 assert( pVal!=0 );
77702 assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
77704 assert( !sqlite3VdbeMemIsRowSet(pVal) );
77705 assert( (pVal->flags & (MEM_Null))==0 );
77706 if( pVal->flags & (MEM_Blob|MEM_Str) ){
77707 if( ExpandBlob(pVal) ) return 0;
77708 pVal->flags |= MEM_Str;
77709 if( pVal->enc != (enc & ~SQLITE_UTF16_ALIGNED) ){
77710 sqlite3VdbeChangeEncoding(pVal, enc & ~SQLITE_UTF16_ALIGNED);
77712 if( (enc & SQLITE_UTF16_ALIGNED)!=0 && 1==(1&SQLITE_PTR_TO_INT(pVal->z)) ){
77713 assert( (pVal->flags & (MEM_Ephem|MEM_Static))!=0 );
77714 if( sqlite3VdbeMemMakeWriteable(pVal)!=SQLITE_OK ){
77718 sqlite3VdbeMemNulTerminate(pVal); /* IMP: R-31275-44060 */
77720 sqlite3VdbeMemStringify(pVal, enc, 0);
77721 assert( 0==(1&SQLITE_PTR_TO_INT(pVal->z)) );
77723 assert(pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) || pVal->db==0
77724 || pVal->db->mallocFailed );
77725 if( pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) ){
77726 assert( sqlite3VdbeMemValidStrRep(pVal) );
77727 return pVal->z;
77743 SQLITE_PRIVATE const void *sqlite3ValueText(sqlite3_value* pVal, u8 enc){
77744 if( !pVal ) return 0;
77745 assert( pVal->db==0 || sqlite3_mutex_held(pVal->db->mutex) );
77747 assert( !sqlite3VdbeMemIsRowSet(pVal) );
77748 if( (pVal->flags&(MEM_Str|MEM_Term))==(MEM_Str|MEM_Term) && pVal->enc==enc ){
77749 assert( sqlite3VdbeMemValidStrRep(pVal) );
77750 return pVal->z;
77752 if( pVal->flags&MEM_Null ){
77755 return valueToText(pVal, enc);
77866 sqlite3_value *pVal = 0; /* New value */
77895 pVal = valueNew(db, pCtx);
77896 if( pVal==0 ){
77903 ctx.pOut = pVal;
77908 sqlite3ErrorMsg(pCtx->pParse, "%s", sqlite3_value_text(pVal));
77910 sqlite3ValueApplyAffinity(pVal, aff, SQLITE_UTF8);
77912 rc = sqlite3VdbeChangeEncoding(pVal, enc);
77913 if( rc==SQLITE_OK && sqlite3VdbeMemTooBig(pVal) ){
77922 pVal = 0;
77931 *ppVal = pVal;
77958 sqlite3_value *pVal = 0;
78000 pVal = valueNew(db, pCtx);
78001 if( pVal==0 ) goto no_mem;
78003 sqlite3VdbeMemSetInt64(pVal, (i64)pExpr->u.iValue*negInt);
78007 sqlite3ValueSetStr(pVal, -1, zVal, SQLITE_UTF8, SQLITE_DYNAMIC);
78010 sqlite3ValueApplyAffinity(pVal, SQLITE_AFF_NUMERIC, SQLITE_UTF8);
78012 sqlite3ValueApplyAffinity(pVal, affinity, SQLITE_UTF8);
78014 assert( (pVal->flags & MEM_IntReal)==0 );
78015 if( pVal->flags & (MEM_Int|MEM_IntReal|MEM_Real) ){
78016 testcase( pVal->flags & MEM_Int );
78017 testcase( pVal->flags & MEM_Real );
78018 pVal->flags &= ~MEM_Str;
78021 rc = sqlite3VdbeChangeEncoding(pVal, enc);
78025 if( SQLITE_OK==valueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal,pCtx)
78026 && pVal!=0
78028 sqlite3VdbeMemNumerify(pVal);
78029 if( pVal->flags & MEM_Real ){
78030 pVal->u.r = -pVal->u.r;
78031 }else if( pVal->u.i==SMALLEST_INT64 ){
78033 pVal->u.r = -(double)SMALLEST_INT64;
78035 pVal->u.r = LARGEST_INT64;
78037 MemSetTypeFlag(pVal, MEM_Real);
78039 pVal->u.i = -pVal->u.i;
78041 sqlite3ValueApplyAffinity(pVal, affinity, enc);
78044 pVal = valueNew(db, pCtx);
78045 if( pVal==0 ) goto no_mem;
78046 sqlite3VdbeMemSetNull(pVal);
78053 pVal = valueNew(db, pCtx);
78054 if( !pVal ) goto no_mem;
78058 sqlite3VdbeMemSetStr(pVal, sqlite3HexToBlob(db, zVal, nVal), nVal/2,
78064 rc = valueFromFunction(db, pExpr, enc, affinity, &pVal, pCtx);
78068 pVal = valueNew(db, pCtx);
78069 if( pVal ){
78070 pVal->flags = MEM_Int;
78071 pVal->u.i = pExpr->u.zToken[4]==0;
78075 *ppVal = pVal;
78086 if( pCtx==0 ) sqlite3ValueFree(pVal);
78088 assert( pCtx==0 ); sqlite3ValueFree(pVal);
78140 sqlite3_value *pVal = 0;
78148 pVal = valueNew(db, pAlloc);
78149 if( pVal ){
78150 sqlite3VdbeMemSetNull((Mem*)pVal);
78157 pVal = valueNew(db, pAlloc);
78158 if( pVal ){
78159 rc = sqlite3VdbeMemCopy((Mem*)pVal, &v->aVar[iBindVar-1]);
78160 sqlite3ValueApplyAffinity(pVal, affinity, ENC(db));
78161 pVal->db = pParse->db;
78165 rc = valueFromExpr(db, pExpr, ENC(db), affinity, &pVal, pAlloc);
78168 assert( pVal==0 || pVal->db==db );
78169 *ppVal = pVal;
78228 sqlite3_value *pVal = 0;
78232 rc = stat4ValueFromExpr(pParse, pElem, aff, &alloc, &pVal);
78233 if( !pVal ) break;
78356 static SQLITE_NOINLINE int valueBytes(sqlite3_value *pVal, u8 enc){
78357 return valueToText(pVal, enc)!=0 ? pVal->n : 0;
78359 SQLITE_PRIVATE int sqlite3ValueBytes(sqlite3_value *pVal, u8 enc){
78360 Mem *p = (Mem*)pVal;
78362 if( (p->flags & MEM_Str)!=0 && pVal->enc==enc ){
78373 return valueBytes(pVal, enc);
83799 SQLITE_API const void *sqlite3_value_blob(sqlite3_value *pVal){
83800 Mem *p = (Mem*)pVal;
83809 return sqlite3_value_text(pVal);
83812 SQLITE_API int sqlite3_value_bytes(sqlite3_value *pVal){
83813 return sqlite3ValueBytes(pVal, SQLITE_UTF8);
83815 SQLITE_API int sqlite3_value_bytes16(sqlite3_value *pVal){
83816 return sqlite3ValueBytes(pVal, SQLITE_UTF16NATIVE);
83818 SQLITE_API double sqlite3_value_double(sqlite3_value *pVal){
83819 return sqlite3VdbeRealValue((Mem*)pVal);
83821 SQLITE_API int sqlite3_value_int(sqlite3_value *pVal){
83822 return (int)sqlite3VdbeIntValue((Mem*)pVal);
83824 SQLITE_API sqlite_int64 sqlite3_value_int64(sqlite3_value *pVal){
83825 return sqlite3VdbeIntValue((Mem*)pVal);
83827 SQLITE_API unsigned int sqlite3_value_subtype(sqlite3_value *pVal){
83828 Mem *pMem = (Mem*)pVal;
83831 SQLITE_API void *sqlite3_value_pointer(sqlite3_value *pVal, const char *zPType){
83832 Mem *p = (Mem*)pVal;
83844 SQLITE_API const unsigned char *sqlite3_value_text(sqlite3_value *pVal){
83845 return (const unsigned char *)sqlite3ValueText(pVal, SQLITE_UTF8);
83848 SQLITE_API const void *sqlite3_value_text16(sqlite3_value* pVal){
83849 return sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);
83851 SQLITE_API const void *sqlite3_value_text16be(sqlite3_value *pVal){
83852 return sqlite3ValueText(pVal, SQLITE_UTF16BE);
83854 SQLITE_API const void *sqlite3_value_text16le(sqlite3_value *pVal){
83855 return sqlite3ValueText(pVal, SQLITE_UTF16LE);
83862 SQLITE_API int sqlite3_value_type(sqlite3_value* pVal){
83932 if( pVal->flags & MEM_Null ){
83934 }else if( pVal->flags & (MEM_Real|MEM_IntReal) ){
83936 }else if( pVal->flags & MEM_Int ){
83938 }else if( pVal->flags & MEM_Str ){
83941 assert( eType == aType[pVal->flags&MEM_AffMask] );
83944 return aType[pVal->flags&MEM_AffMask];
83948 SQLITE_API int sqlite3_value_nochange(sqlite3_value *pVal){
83949 return (pVal->flags&(MEM_Null|MEM_Zero))==(MEM_Null|MEM_Zero);
83953 SQLITE_API int sqlite3_value_frombind(sqlite3_value *pVal){
83954 return (pVal->flags&MEM_FromBind)!=0;
86281 SQLITE_API int sqlite3_value_numeric_type(sqlite3_value *pVal){
86282 int eType = sqlite3_value_type(pVal);
86284 Mem *pMem = (Mem*)pVal;
86286 eType = sqlite3_value_type(pVal);
86296 sqlite3_value *pVal,
86300 applyAffinity((Mem *)pVal, affinity, enc);
96514 Mem *pVal /* Memory cell containing record */
96526 getVarint32NR((const u8*)&pVal->z[1], t);
96553 nReq = pVal->n + sizeof(SorterRecord);
96554 nPMA = pVal->n + sqlite3VarintLen(pVal->n);
96612 memcpy(SRVAL(pNew), pVal->z, pVal->n);
96613 pNew->nVal = pVal->n;
97461 ** Compare the key in memory cell pVal with the key that the sorter cursor
97466 ** less than pVal. Even if pVal also contains NULL values.
97470 ** key in pVal is smaller than, equal to or larger than the current sorter
97478 Mem *pVal, /* Value to compare to current sorter key */
97486 void *pKey; int nKey; /* Sorter key to compare pVal with */
97508 *pRes = sqlite3VdbeRecordCompare(pVal->n, pVal->z, r2);
107133 sqlite3_value *pVal = 0;
107135 rc = sqlite3ValueFromExpr(db, pDflt, SQLITE_UTF8, SQLITE_AFF_BLOB, &pVal);
107141 if( !pVal ){
107145 sqlite3ValueFree(pVal);
146592 sqlite3_value *pVal = 0;
146610 pVal = sqlite3VdbeGetBoundValue(pReprepare, iCol, SQLITE_AFF_BLOB);
146611 if( pVal && sqlite3_value_type(pVal)==SQLITE_TEXT ){
146612 z = sqlite3_value_text(pVal);
146686 sqlite3ValueFree(pVal);
146717 sqlite3ValueFree(pVal);
149709 sqlite3_value *pVal = 0; /* Value extracted from record */
149725 rc = sqlite3Stat4Column(db, p->aSample[i].p, p->aSample[i].n, nEq, &pVal);
149727 int res = sqlite3MemCompare(p1, pVal, pColl);
149731 int res = sqlite3MemCompare(p2, pVal, pColl);
149757 sqlite3ValueFree(pVal);
154418 sqlite3_value *pVal;
154434 sqlite3_value_free(p->pVal);
154435 p->pVal = sqlite3_value_dup(apArg[0]);
154436 if( p->pVal==0 ){
154455 sqlite3_value_free(p->pVal);
154456 p->pVal = 0;
154463 if( p && p->pVal ){
154464 sqlite3_result_value(pCtx, p->pVal);
154470 if( p && p->pVal ){
154471 sqlite3_result_value(pCtx, p->pVal);
154472 sqlite3_value_free(p->pVal);
154473 p->pVal = 0;
156317 sqlite3_value *pVal = 0;
156318 sqlite3ValueFromExpr(db, pExpr, db->enc, SQLITE_AFF_NUMERIC, &pVal);
156319 if( pVal && sqlite3_value_int(pVal)>0 ){
156322 sqlite3ValueFree(pVal);
163936 sqlite3_value *pVal;
163944 pVal = sqlite3ValueNew(0);
163945 sqlite3ValueSetStr(pVal, -1, zSql, SQLITE_UTF16NATIVE, SQLITE_STATIC);
163946 zSql8 = sqlite3ValueText(pVal, SQLITE_UTF8);
163952 sqlite3ValueFree(pVal);
167499 sqlite3_value *pVal;
167511 pVal = sqlite3ValueNew(0);
167512 sqlite3ValueSetStr(pVal, -1, zFilename, SQLITE_UTF16NATIVE, SQLITE_STATIC);
167513 zFilename8 = sqlite3ValueText(pVal, SQLITE_UTF8);
167524 sqlite3ValueFree(pVal);
170494 ** to *pVal.
170496 static void fts3GetDeltaVarint(char **pp, sqlite3_int64 *pVal){
170499 *pVal += iVal;
170506 ** and sets *pVal by the varint value.
170514 sqlite3_int64 *pVal
170527 *pVal = iVal;
172505 ** If bDescIdx is false, the value read is added to *pVal before returning.
172506 ** If it is true, the value read is subtracted from *pVal before this
172513 sqlite3_int64 *pVal /* IN/OUT: Integer value */
172521 *pVal = (i64)((u64)*pVal - iVal);
172523 *pVal = (i64)((u64)*pVal + iVal);
173271 ** If the numeric type of argument pVal is "integer", then return it
173275 static sqlite3_int64 fts3DocidRange(sqlite3_value *pVal, i64 iDefault){
173276 if( pVal ){
173277 int eType = sqlite3_value_numeric_type(pVal);
173279 return sqlite3_value_int64(pVal);
173684 sqlite3_value *pVal, /* argv[0] passed to function */
173688 *ppCsr = (Fts3Cursor*)sqlite3_value_pointer(pVal, "fts3cursor");
185621 ** Argument pVal contains the result of <expr>. Currently the only
185624 static int fts3SpecialInsert(Fts3Table *p, sqlite3_value *pVal){
185626 const char *zVal = (const char *)sqlite3_value_text(pVal);
185627 int nVal = sqlite3_value_bytes(pVal);
195729 /* Parse out a number. Write the value into *pVal if pVal!=0.
195732 static int geopolyParseNumber(GeoParse *p, GeoCoord *pVal){
195767 if( pVal ){
195773 *pVal = r;
195775 *pVal = (GeoCoord)atof((const char*)p->z);
195869 sqlite3_value *pVal, /* The value to decode */
195874 if( sqlite3_value_type(pVal)==SQLITE_BLOB
195875 && (nByte = sqlite3_value_bytes(pVal))>=(4+6*sizeof(GeoCoord))
195877 const unsigned char *a = sqlite3_value_blob(pVal);
195903 }else if( sqlite3_value_type(pVal)==SQLITE_TEXT ){
195904 const unsigned char *zJson = sqlite3_value_text(pVal);
202307 sqlite3_value *pVal;
202348 pVal = sqlite3_column_value(pIter->pSelect, i);
202349 p->rc = sqlite3_bind_value(pWriter, i+1, pVal);
202367 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
202368 p->rc = sqlite3_bind_value(pWriter, pIter->nCol+1, pVal);
202414 sqlite3_value *pVal;
202423 pVal = sqlite3_column_value(pIter->pSelect, i);
202425 p->rc = sqlite3_bind_value(pUpdate, i+1, pVal);
202433 pVal = sqlite3_column_value(pIter->pSelect, pIter->nCol+1);
202434 p->rc = sqlite3_bind_value(pUpdate, pIter->nCol+1, pVal);
206101 sqlite3_value *pVal;
206104 rc = pSession->hook.xNew(pSession->hook.pCtx, i, &pVal);
206106 rc = pSession->hook.xOld(pSession->hook.pCtx, i, &pVal);
206110 eType = sqlite3_value_type(pVal);
206115 iVal = sqlite3_value_int64(pVal);
206117 double rVal = sqlite3_value_double(pVal);
206126 z = (const u8 *)sqlite3_value_text(pVal);
206128 z = (const u8 *)sqlite3_value_blob(pVal);
206130 n = sqlite3_value_bytes(pVal);
206431 sqlite3_value *pVal; /* Value returned by preupdate_new/old */
206442 rc = pSession->hook.xNew(pSession->hook.pCtx, iCol, &pVal);
206445 rc = pSession->hook.xOld(pSession->hook.pCtx, iCol, &pVal);
206448 if( sqlite3_value_type(pVal)!=eType ) return 0;
206459 if( sqlite3_value_int64(pVal)!=iVal ) return 0;
206464 if( sqlite3_value_double(pVal)!=rVal ) return 0;
206470 if( sqlite3_value_bytes(pVal)!=n ) return 0;
206472 z = sqlite3_value_text(pVal);
206474 z = sqlite3_value_blob(pVal);
206715 sqlite3_value *pVal = 0;
206716 int rc = p->hook.xOld(p->hook.pCtx, iCol, &pVal);
206717 if( rc==SQLITE_OK && iCol==1 && sqlite3_value_type(pVal)==SQLITE_NULL ){
206718 pVal = p->pSession->pZeroBlob;
206720 *ppVal = pVal;
206725 sqlite3_value *pVal = 0;
206726 int rc = p->hook.xNew(p->hook.pCtx, iCol, &pVal);
206727 if( rc==SQLITE_OK && iCol==1 && sqlite3_value_type(pVal)==SQLITE_NULL ){
206728 pVal = p->pSession->pZeroBlob;
206730 *ppVal = pVal;
207466 static void sessionAppendValue(SessionBuffer *p, sqlite3_value *pVal, int *pRc){
207470 rc = sessionSerializeValue(0, pVal, &nByte);
207473 rc = sessionSerializeValue(&p->aBuf[p->nBuf], pVal, 0);
208345 sqlite3_value *pVal, /* Set the value of this object */
208357 sqlite3ValueSetStr(pVal, nData, (char*)aCopy, enc, sqlite3_free);
209026 sqlite3_value *pVal = apVal[iCol + (abPK[iCol] ? 0 : nCol)];
209027 sessionAppendValue(&sOut, pVal, &rc);
209034 sqlite3_value *pVal = (abPK[iCol] ? 0 : apVal[iCol]);
209035 sessionAppendValue(&sOut, pVal, &rc);
209475 sqlite3_value *pVal /* Value to bind */
209477 int eType = sqlite3_value_type(pVal);
209478 /* COVERAGE: The (pVal->z==0) branch is never true using current versions
209480 ** the (pVal->z) variable remains as it was or the type of the value is
209482 if( (eType==SQLITE_TEXT || eType==SQLITE_BLOB) && pVal->z==0 ){
209485 ** a conflict-handler) has zeroed the pVal->z pointer. Return NOMEM. */
209488 return sqlite3_bind_value(pStmt, i, pVal);
209523 sqlite3_value *pVal;
209524 (void)xValue(pIter, i, &pVal);
209525 if( pVal==0 ){
209530 rc = sessionBindValue(pStmt, i+1, pVal);
209616 sqlite3_value *pVal = 0;
209618 sqlite3changeset_old(pIter, i, &pVal);
209620 sqlite3changeset_new(pIter, i, &pVal);
209622 sessionAppendValue(&p->rebase, pVal, &rc);
214475 ** Return the value in pVal interpreted as utf-8 text. Except, if pVal
214479 static const char *fts5ValueToText(sqlite3_value *pVal){
214480 const char *zRet = (const char*)sqlite3_value_text(pVal);
216050 sqlite3_value *pVal,
216057 if( SQLITE_INTEGER==sqlite3_value_numeric_type(pVal) ){
216058 pgsz = sqlite3_value_int(pVal);
216069 if( SQLITE_INTEGER==sqlite3_value_numeric_type(pVal) ){
216070 nHashSize = sqlite3_value_int(pVal);
216081 if( SQLITE_INTEGER==sqlite3_value_numeric_type(pVal) ){
216082 nAutomerge = sqlite3_value_int(pVal);
216094 if( SQLITE_INTEGER==sqlite3_value_numeric_type(pVal) ){
216095 nUsermerge = sqlite3_value_int(pVal);
216106 if( SQLITE_INTEGER==sqlite3_value_numeric_type(pVal) ){
216107 nCrisisMerge = sqlite3_value_int(pVal);
216119 const char *zIn = (const char*)sqlite3_value_text(pVal);
216165 sqlite3_value *pVal = sqlite3_column_value(p, 1);
216167 iVersion = sqlite3_value_int(pVal);
216170 sqlite3Fts5ConfigSetValue(pConfig, zK, pVal, &bDummy);
227700 static i64 fts5GetRowidLimit(sqlite3_value *pVal, i64 iDefault){
227701 if( pVal ){
227702 int eType = sqlite3_value_numeric_type(pVal);
227704 return sqlite3_value_int64(pVal);
228022 ** INSERT INTO fts(fts, rank) VALUES($pCmd, $pVal)
228024 ** Argument pVal is the value assigned to column "fts" by the INSERT
228035 sqlite3_value *pVal /* Value inserted into rank column */
228063 int nMerge = sqlite3_value_int(pVal);
228066 int iArg = sqlite3_value_int(pVal);
228070 pConfig->bPrefixIndex = sqlite3_value_int(pVal);
228075 rc = sqlite3Fts5ConfigSetValue(pTab->p.pConfig, zCmd, pVal, &bError);
228081 rc = sqlite3Fts5StorageConfigValue(pTab->pStorage, zCmd, pVal, 0);
230577 sqlite3_value *pVal,
230584 if( pVal ){
230585 sqlite3_bind_value(pReplace, 2, pVal);
230593 if( rc==SQLITE_OK && pVal ){