Lines Matching refs:z
7957 SQLITE_API int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset);
14724 char *z; /* Pointer to data for string (char array) types */ member
15152 SQLITE_PRIVATE void sqlite3VdbeSetSql(Vdbe*, const char *z, int n, u8);
17240 const char *z; /* Text of the token. Not NULL-terminated! */ member
19092 SQLITE_PRIVATE int sqlite3AtoF(const char *z, double*, int, u8);
19149 SQLITE_PRIVATE void *sqlite3HexToBlob(sqlite3*, const char *z, int n);
19185 SQLITE_PRIVATE u8 sqlite3GetBoolean(const char *z,u8);
19323 #define sqlite3TableLock(v,w,x,y,z) argument
19395 #define sqlite3WithPush(x,y,z) argument
19405 #define sqlite3UpsertNew(v,w,x,y,z) ((Upsert*)0) argument
20146 char *z; /* String or BLOB value */ member
20302 char z[8]; /* Dequoted value for the string */ member
21575 const char *z, /* The text of the modifier */ in parseModifier() argument
21581 switch(sqlite3UpperToLower[(u8)z[0]] ){ in parseModifier()
21589 if( sqlite3_stricmp(z, "localtime")==0 && sqlite3NotPureFunc(pCtx) ){ in parseModifier()
21604 if( sqlite3_stricmp(z, "unixepoch")==0 && p->rawS ){ in parseModifier()
21615 else if( sqlite3_stricmp(z, "utc")==0 && sqlite3NotPureFunc(pCtx) ){ in parseModifier()
21641 if( sqlite3_strnicmp(z, "weekday ", 8)==0 in parseModifier()
21642 && sqlite3AtoF(&z[8], &r, sqlite3Strlen30(&z[8]), SQLITE_UTF8) in parseModifier()
21664 if( sqlite3_strnicmp(z, "start of ", 9)!=0 ) break; in parseModifier()
21666 z += 9; in parseModifier()
21674 if( sqlite3_stricmp(z,"month")==0 ){ in parseModifier()
21677 }else if( sqlite3_stricmp(z,"year")==0 ){ in parseModifier()
21681 }else if( sqlite3_stricmp(z,"day")==0 ){ in parseModifier()
21700 for(n=1; z[n] && z[n]!=':' && !sqlite3Isspace(z[n]); n++){} in parseModifier()
21701 if( !sqlite3AtoF(z, &r, n, SQLITE_UTF8) ){ in parseModifier()
21705 if( z[n]==':' ){ in parseModifier()
21711 const char *z2 = z; in parseModifier()
21721 if( z[0]=='-' ) tx.iJD = -tx.iJD; in parseModifier()
21731 z += n; in parseModifier()
21732 while( sqlite3Isspace(*z) ) z++; in parseModifier()
21733 n = sqlite3Strlen30(z); in parseModifier()
21735 if( sqlite3UpperToLower[(u8)z[n-1]]=='s' ) n--; in parseModifier()
21741 && sqlite3_strnicmp(aXformType[i].zName, z, n)==0 in parseModifier()
21797 const unsigned char *z; in isDate() local
21807 z = sqlite3_value_text(argv[0]); in isDate()
21808 if( !z || parseDateOrTime(context, (char*)z, p) ){ in isDate()
21813 z = sqlite3_value_text(argv[i]); in isDate()
21815 if( z==0 || parseModifier(context, (char*)z, n, p) ) return 1; in isDate()
21930 char *z; in strftimeFunc() local
21976 z = zBuf; in strftimeFunc()
21981 z = sqlite3DbMallocRawNN(db, (int)n); in strftimeFunc()
21982 if( z==0 ){ in strftimeFunc()
21991 z[j++] = zFmt[i]; in strftimeFunc()
21995 case 'd': sqlite3_snprintf(3, &z[j],"%02d",x.D); j+=2; break; in strftimeFunc()
21999 sqlite3_snprintf(7, &z[j],"%06.3f", s); in strftimeFunc()
22000 j += sqlite3Strlen30(&z[j]); in strftimeFunc()
22003 case 'H': sqlite3_snprintf(3, &z[j],"%02d",x.h); j+=2; break; in strftimeFunc()
22016 sqlite3_snprintf(3, &z[j],"%02d",(nDay+7-wd)/7); in strftimeFunc()
22019 sqlite3_snprintf(4, &z[j],"%03d",nDay+1); in strftimeFunc()
22025 sqlite3_snprintf(20, &z[j],"%.16g",x.iJD/86400000.0); in strftimeFunc()
22026 j+=sqlite3Strlen30(&z[j]); in strftimeFunc()
22029 case 'm': sqlite3_snprintf(3, &z[j],"%02d",x.M); j+=2; break; in strftimeFunc()
22030 case 'M': sqlite3_snprintf(3, &z[j],"%02d",x.m); j+=2; break; in strftimeFunc()
22032 sqlite3_snprintf(30,&z[j],"%lld", in strftimeFunc()
22034 j += sqlite3Strlen30(&z[j]); in strftimeFunc()
22037 case 'S': sqlite3_snprintf(3,&z[j],"%02d",(int)x.s); j+=2; break; in strftimeFunc()
22039 z[j++] = (char)(((x.iJD+129600000)/86400000) % 7) + '0'; in strftimeFunc()
22043 sqlite3_snprintf(5,&z[j],"%04d",x.Y); j+=sqlite3Strlen30(&z[j]); in strftimeFunc()
22046 default: z[j++] = '%'; break; in strftimeFunc()
22050 z[j] = 0; in strftimeFunc()
22051 sqlite3_result_text(context, z, -1, in strftimeFunc()
22052 z==zBuf ? SQLITE_TRANSIENT : SQLITE_DYNAMIC); in strftimeFunc()
23286 char *z; in sqlite3MemMalloc() local
23298 z = p; in sqlite3MemMalloc()
23299 pBt = (void**)&z[mem.nTitle]; in sqlite3MemMalloc()
23325 memcpy(z, mem.zTitle, mem.nTitle); in sqlite3MemMalloc()
23345 char *z; in sqlite3MemFree() local
23366 z = (char*)pBt; in sqlite3MemFree()
23367 z -= pHdr->nTitle; in sqlite3MemFree()
23369 randomFill(z, sizeof(void*)*pHdr->nBacktraceSlots + sizeof(*pHdr) + in sqlite3MemFree()
23371 free(z); in sqlite3MemFree()
23529 char *z = (char*)pHdr; in sqlite3MemdebugDump() local
23530 z -= pHdr->nBacktraceSlots*sizeof(void*) + pHdr->nTitle; in sqlite3MemdebugDump()
23532 pHdr->iSize, &pHdr[1], pHdr->nTitle ? z : "???"); in sqlite3MemdebugDump()
27113 SQLITE_PRIVATE char *sqlite3DbStrDup(sqlite3 *db, const char *z){
27116 if( z==0 ){
27119 n = strlen(z) + 1;
27122 memcpy(zNew, z, n);
27126 SQLITE_PRIVATE char *sqlite3DbStrNDup(sqlite3 *db, const char *z, u64 n){
27129 if( z==0 ){
27135 memcpy(zNew, z, (size_t)n);
27401 char *z;
27407 z = sqlite3DbMallocRaw(pAccum->db, n);
27408 if( z==0 ){
27411 return z;
27982 unsigned char *z = (unsigned char*)bufpt;
27983 while( precision-- > 0 && z[0] ){
27984 SQLITE_SKIP_UTF8(z);
27986 length = (int)(z - (unsigned char*)bufpt);
28054 sqlite3_str_append(pAccum, (const char*)pToken->z, pToken->n);
28179 static void SQLITE_NOINLINE enlargeAndAppend(StrAccum *p, const char *z, int N){
28182 memcpy(&p->zText[p->nChar], z, N);
28191 SQLITE_API void sqlite3_str_append(sqlite3_str *p, const char *z, int N){
28192 assert( z!=0 || N==0 );
28197 enlargeAndAppend(p,z,N);
28201 memcpy(&p->zText[p->nChar-N], z, N);
28208 SQLITE_API void sqlite3_str_appendall(sqlite3_str *p, const char *z){
28209 sqlite3_str_append(p, z, sqlite3Strlen30(z));
28254 char *z;
28256 z = sqlite3StrAccumFinish(p);
28259 z = 0;
28261 return z;
28335 char *z;
28343 z = sqlite3StrAccumFinish(&acc);
28347 return z;
28356 char *z;
28358 z = sqlite3VMPrintf(db, zFormat, ap);
28360 return z;
28368 char *z;
28383 z = sqlite3StrAccumFinish(&acc);
28384 return z;
28393 char *z;
28398 z = sqlite3_vmprintf(zFormat, ap);
28400 return z;
28432 char *z;
28435 z = sqlite3_vsnprintf(n, zBuf, zFormat, ap);
28437 return z;
29867 unsigned char *z; /* Output iterator */
29896 zIn = (u8*)pMem->z;
29932 zIn = (u8*)pMem->z;
29938 z = zOut;
29945 WRITE_UTF16LE(z, c);
29952 WRITE_UTF16BE(z, c);
29955 pMem->n = (int)(z - zOut);
29956 *z++ = 0;
29963 WRITE_UTF8(z, c);
29969 WRITE_UTF8(z, c);
29972 pMem->n = (int)(z - zOut);
29974 *z = 0;
29981 pMem->z = (char*)zOut;
29982 pMem->zMalloc = pMem->z;
29983 pMem->szMalloc = sqlite3DbMallocSize(pMem->db, pMem->z);
30013 u8 b1 = *(u8 *)pMem->z;
30014 u8 b2 = *(((u8 *)pMem->z) + 1);
30027 memmove(pMem->z, &pMem->z[2], pMem->n);
30028 pMem->z[pMem->n] = '\0';
30029 pMem->z[pMem->n+1] = '\0';
30047 const u8 *z = (const u8*)zIn;
30050 zTerm = &z[nByte];
30054 assert( z<=zTerm );
30055 while( *z!=0 && z<zTerm ){
30056 SQLITE_SKIP_UTF8(z);
30099 SQLITE_PRIVATE char *sqlite3Utf16to8(sqlite3 *db, const void *z, int nByte, u8 enc){
30103 sqlite3VdbeMemSetStr(&m, z, nByte, enc, SQLITE_STATIC);
30107 m.z = 0;
30111 assert( m.z || db->mallocFailed );
30112 return m.z;
30122 unsigned char const *z = zIn;
30127 READ_UTF16BE(z, 1, c);
30132 READ_UTF16LE(z, 1, c);
30136 return (int)(z-(unsigned char const *)zIn);
30148 unsigned char *z;
30153 z = zBuf;
30154 WRITE_UTF8(z, i);
30155 n = (int)(z-zBuf);
30157 z[0] = 0;
30158 z = zBuf;
30159 c = sqlite3Utf8Read((const u8**)&z);
30164 assert( (z-zBuf)==n );
30168 z = zBuf;
30169 WRITE_UTF16LE(z, i);
30170 n = (int)(z-zBuf);
30172 z[0] = 0;
30173 z = zBuf;
30174 READ_UTF16LE(z, 1, c);
30176 assert( (z-zBuf)==n );
30180 z = zBuf;
30181 WRITE_UTF16BE(z, i);
30182 n = (int)(z-zBuf);
30184 z[0] = 0;
30185 z = zBuf;
30186 READ_UTF16BE(z, 1, c);
30188 assert( (z-zBuf)==n );
30292 volatile double z = y;
30293 rc = (y!=z);
30310 SQLITE_PRIVATE int sqlite3Strlen30(const char *z){
30311 if( z==0 ) return 0;
30312 return 0x3fffffff & (int)strlen(z);
30388 char *z;
30391 z = sqlite3VMPrintf(db, zFormat, ap);
30393 sqlite3ValueSetStr(db->pErr, -1, z, SQLITE_UTF8, SQLITE_DYNAMIC);
30461 SQLITE_PRIVATE void sqlite3Dequote(char *z){
30464 if( z==0 ) return;
30465 quote = z[0];
30469 assert( z[i] );
30470 if( z[i]==quote ){
30471 if( z[i+1]==quote ){
30472 z[j++] = quote;
30478 z[j++] = z[i];
30481 z[j] = 0;
30492 SQLITE_PRIVATE void sqlite3TokenInit(Token *p, char *z){
30493 p->z = z;
30494 p->n = sqlite3Strlen30(z);
30605 SQLITE_PRIVATE int sqlite3AtoF(const char *z, double *pResult, int length, u8 enc){
30608 const char *zEnd = z + length;
30629 for(i=3-enc; i<length && z[i]==0; i+=2){}
30631 zEnd = &z[i^1];
30632 z += (enc&1);
30636 while( z<zEnd && sqlite3Isspace(*z) ) z+=incr;
30637 if( z>=zEnd ) return 0;
30640 if( *z=='-' ){
30642 z+=incr;
30643 }else if( *z=='+' ){
30644 z+=incr;
30648 while( z<zEnd && sqlite3Isdigit(*z) && s<((LARGEST_INT64-9)/10) ){
30649 s = s*10 + (*z - '0');
30650 z+=incr; nDigits++;
30655 while( z<zEnd && sqlite3Isdigit(*z) ){ z+=incr; nDigits++; d++; }
30656 if( z>=zEnd ) goto do_atof_calc;
30659 if( *z=='.' ){
30660 z+=incr;
30663 while( z<zEnd && sqlite3Isdigit(*z) ){
30665 s = s*10 + (*z - '0');
30668 z+=incr; nDigits++;
30671 if( z>=zEnd ) goto do_atof_calc;
30674 if( *z=='e' || *z=='E' ){
30675 z+=incr;
30681 if( z>=zEnd ) goto do_atof_calc; /*PREVENTS-HARMLESS-OVERREAD*/
30684 if( *z=='-' ){
30686 z+=incr;
30687 }else if( *z=='+' ){
30688 z+=incr;
30691 while( z<zEnd && sqlite3Isdigit(*z) ){
30692 e = e<10000 ? (e*10 + (*z - '0')) : 10000;
30693 z+=incr;
30699 while( z<zEnd && sqlite3Isspace(*z) ) z+=incr;
30775 return z==zEnd && nDigits>0 && eValid && nonNum==0;
30777 return !sqlite3Atoi64(z, pResult, length, enc);
30929 SQLITE_PRIVATE int sqlite3DecOrHexToI64(const char *z, i64 *pOut){
30931 if( z[0]=='0'
30932 && (z[1]=='x' || z[1]=='X')
30936 for(i=2; z[i]=='0'; i++){}
30937 for(k=i; sqlite3Isxdigit(z[k]); k++){
30938 u = u*16 + sqlite3HexToInt(z[k]);
30941 return (z[k]==0 && k-i<=16) ? 0 : 2;
30945 return sqlite3Atoi64(z, pOut, sqlite3Strlen30(z), SQLITE_UTF8);
31018 SQLITE_PRIVATE int sqlite3Atoi(const char *z){
31020 if( z ) sqlite3GetInt32(z, &x);
31471 SQLITE_PRIVATE void *sqlite3HexToBlob(sqlite3 *db, const char *z, int n){
31479 zBlob[i/2] = (sqlite3HexToInt(z[i])<<4) | sqlite3HexToInt(z[i+1]);
31635 SQLITE_PRIVATE void sqlite3FileSuffix3(const char *zBaseFilename, char *z){
31641 sz = sqlite3Strlen30(z);
31642 for(i=sz-1; i>0 && z[i]!='/' && z[i]!='.'; i--){}
31643 if( z[i]=='.' && ALWAYS(sz>i+4) ) memmove(&z[i+1], &z[sz-3], 4);
31788 char *z; /* Pointer to where zName will be stored */
31805 z = (char*)&pIn[i+2];
31808 memcpy(z, zName, nName);
31809 z[nName] = 0;
31840 const char *z = (const char*)&pIn[i+2];
31841 if( strncmp(z,zName,nName)==0 && z[nName]==0 ) return pIn[i];
31903 static unsigned int strHash(const char *z){
31906 while( (c = (unsigned char)*z++)!=0 ){ /*OPTIMIZATION-IF-TRUE*/
33167 static int robust_open(const char *z, int f, mode_t m){
33172 fd = osOpen(z,f|O_CLOEXEC,m2);
33174 fd = osOpen(z,f,m2);
33183 "attempt to open \"%s\" as file descriptor %d", z, fd);
33424 static int vxworksSimplifyName(char *z, int n){
33426 while( n>1 && z[n-1]=='/' ){ n--; }
33428 if( z[i]=='/' ){
33429 if( z[i+1]=='/' ) continue;
33430 if( z[i+1]=='.' && i+2<n && z[i+2]=='/' ){
33434 if( z[i+1]=='.' && i+3<n && z[i+2]=='.' && z[i+3]=='/' ){
33435 while( j>0 && z[j-1]!='/' ){ j--; }
33441 z[j++] = z[i];
33443 z[j] = 0;
37749 static const sqlite3_io_methods *FINDER##Impl(const char *z, unixFile *p){ \
37750 UNUSED_PARAMETER(z); UNUSED_PARAMETER(p); \
38384 const char *z = sqlite3_uri_parameter(zPath, "modeof");
38385 if( z ){
38386 rc = getFileMode(z, pMode, pUid, pGid);
46900 const void *z,
46916 memcpy(p->aData+iOfst, z, iAmt);
50477 # define sqlite3WalOpen(x,y,z) 0
50479 # define sqlite3WalClose(v,w,x,y,z) 0
50480 # define sqlite3WalBeginReadTransaction(y,z) 0
50481 # define sqlite3WalEndReadTransaction(z)
50485 # define sqlite3WalUndo(x,y,z) 0
50486 # define sqlite3WalSavepoint(y,z)
50487 # define sqlite3WalSavepointUndo(y,z) 0
50488 # define sqlite3WalFrames(u,v,w,x,y,z) 0
50489 # define sqlite3WalCheckpoint(q,r,s,t,u,v,w,x,y,z) 0
50490 # define sqlite3WalCallback(z) 0
50491 # define sqlite3WalExclusiveMode(y,z) 0
50492 # define sqlite3WalHeapMemory(z) 0
50493 # define sqlite3WalFramesize(z) 0
50494 # define sqlite3WalFindFrame(x,y,z) 0
51439 # define pagerOpenWalIfPresent(z) SQLITE_OK
51440 # define pagerBeginReadTransaction(z) SQLITE_OK
55367 const char *z;
55376 z = zUri = &zFilename[sqlite3Strlen30(zFilename)+1];
55377 while( *z ){
55378 z += sqlite3Strlen30(z)+1;
55379 z += sqlite3Strlen30(z)+1;
55381 nUri = (int)(&z[1] - zUri);
63740 #define invalidateIncrblobCursors(w,x,y,z)
64260 #define ptrmapPut(w,x,y,z,rc)
64261 #define ptrmapGet(w,x,y,z) SQLITE_OK
64262 #define ptrmapPutOvflPtr(x, y, z, rc)
68259 # define assertParentIndex(x,y,z)
70513 u8 *z;
70515 z = findCell(pPage, j);
70516 pPage->xParseCell(pPage, z, &info);
70518 Pgno ovfl = get4byte(&z[info.nSize-4]);
70523 Pgno child = get4byte(z);
73488 SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor *pCsr, u32 offset, u32 amt, void *z){
73530 return accessPayload(pCsr, offset, amt, (unsigned char *)z, 1);
74506 ((p->szMalloc>0 && p->z==p->zMalloc)? 1 : 0) +
74538 char *z;
74547 z = p->z;
74552 if( p->enc==SQLITE_UTF16BE ) z++;
74555 if( zBuf[j++]!=z[i] ) return 0;
74617 testcase( bPreserve && pMem->z==0 );
74621 if( pMem->szMalloc>0 && bPreserve && pMem->z==pMem->zMalloc ){
74622 pMem->z = pMem->zMalloc = sqlite3DbReallocOrFree(pMem->db, pMem->z, n);
74630 pMem->z = 0;
74637 if( bPreserve && pMem->z ){
74638 assert( pMem->z!=pMem->zMalloc );
74639 memcpy(pMem->zMalloc, pMem->z, pMem->n);
74643 pMem->xDel((void *)(pMem->z));
74646 pMem->z = pMem->zMalloc;
74671 pMem->z = pMem->zMalloc;
74684 pMem->z[pMem->n] = 0;
74685 pMem->z[pMem->n+1] = 0;
74701 if( pMem->szMalloc==0 || pMem->z!=pMem->zMalloc ){
74737 memset(&pMem->z[pMem->n], 0, pMem->u.nZero);
74796 sqlite3_snprintf(nByte, pMem->z, "%lld", pMem->u.i);
74799 sqlite3_snprintf(nByte, pMem->z, "%!.15g", pMem->u.r);
74801 assert( pMem->z!=0 );
74802 pMem->n = sqlite3Strlen30NN(pMem->z);
74887 p->xDel((void *)p->z);
74908 p->z = 0;
74971 sqlite3Atoi64(pMem->z, &value, pMem->n, pMem->enc);
74984 assert( pMem->z || pMem->n==0 );
75000 sqlite3AtoF(pMem->z, &val, pMem->n, pMem->enc);
75108 rc = sqlite3Atoi64(pMem->z, &pMem->u.i, pMem->n, pMem->enc);
75113 sqlite3AtoF(pMem->z, &pMem->u.r, pMem->n, pMem->enc);
75218 pMem->z = 0;
75260 pMem->z = pPtr;
75306 pMem->z = (char*)p;
75351 assert( (mFlags&MEM_Str)==0 || (pMem->n==pX->n && pMem->z==pX->z) );
75443 const char *z, /* String pointer */
75456 if( !z ){
75470 nByte = 0x7fffffff & (int)strlen(z);
75472 for(nByte=0; nByte<=iLimit && (z[nByte] | z[nByte+1]); nByte+=2){}
75495 memcpy(pMem->z, z, nAlloc);
75498 pMem->z = (char *)z;
75500 pMem->zMalloc = pMem->z;
75552 rc = sqlite3BtreePayload(pCur, offset, amt, pMem->z);
75554 pMem->z[amt] = 0; /* Overrun area used when reading malformed records */
75583 pMem->z = &zData[offset];
75610 if( (enc & SQLITE_UTF16_ALIGNED)!=0 && 1==(1&SQLITE_PTR_TO_INT(pVal->z)) ){
75619 assert( 0==(1&SQLITE_PTR_TO_INT(pVal->z)) );
75625 return pVal->z;
75648 return pVal->z;
76273 const void *z, /* Text of the new string */
76277 if( v ) sqlite3VdbeMemSetStr((Mem *)v, z, n, enc, xDel);
76374 SQLITE_PRIVATE void sqlite3VdbeSetSql(Vdbe *p, const char *z, int n, u8 prepFlags){
76381 p->zSql = sqlite3DbStrNDup(p->db, z, n);
76388 SQLITE_PRIVATE void sqlite3VdbeAddDblquoteStr(sqlite3 *db, Vdbe *p, const char *z){
76390 int n = sqlite3Strlen30(z);
76392 sizeof(*pStr)+n+1-sizeof(pStr->z));
76396 memcpy(pStr->z, z, n+1);
76415 if( strcmp(zId, pStr->z)==0 ) return 1;
76609 const char *z = va_arg(ap, const char*);
76610 sqlite3VdbeAddOp4(p, z==0 ? OP_Null : OP_String8, 0, iDest+i, 0, z, 0);
76704 sqlite3ExplainBreakpoint(bPush?"PUSH":"", sqlite3VdbeGetOp(v,-1)->p4.z);
77416 pOp->p4.z = 0;
77465 pOp->p4.z = sqlite3DbStrNDup(p->db, zP4, n);
77851 zP4 = pMem->z;
77897 zP4 = pOp->p4.z;
78192 apSub = (SubProgram **)pSub->z;
78238 apSub = (SubProgram **)pSub->z;
78263 pMem->z = (char*)sqlite3OpcodeName(pOp->opcode); /* Opcode */
78264 assert( pMem->z!=0 );
78265 pMem->n = sqlite3Strlen30(pMem->z);
78287 zP4 = displayP4(pOp, pMem->z, pMem->szMalloc);
78288 if( zP4!=pMem->z ){
78292 assert( pMem->z!=0 );
78293 pMem->n = sqlite3Strlen30(pMem->z);
78305 sqlite3_snprintf(3, pMem->z, "%.2x", pOp->p5); /* P5 */
78315 pMem->n = displayComment(pOp, zP4, pMem->z, 500);
78337 const char *z = 0;
78339 z = p->zSql;
78342 if( pOp->opcode==OP_Init && pOp->p4.z!=0 ){
78343 z = pOp->p4.z;
78344 while( sqlite3Isspace(*z) ) z++;
78347 if( z ) printf("SQL: [%s]\n", z);
78361 if( pOp->opcode==OP_Init && pOp->p4.z!=0 ){
78363 char z[1000];
78364 sqlite3_snprintf(sizeof(z), z, "%s", pOp->p4.z);
78365 for(i=0; sqlite3Isspace(z[i]); i++){}
78366 for(j=0; z[i]; i++){
78367 if( sqlite3Isspace(z[i]) ){
78368 if( z[i-1]!=' ' ){
78369 z[j++] = ' ';
78372 z[j++] = z[i];
78375 z[j] = 0;
78376 sqlite3IoTrace("SQL %s\n", z);
79921 if( len>0 ) memcpy(buf, pMem->z, len);
80066 pMem->z = (char *)buf;
80134 pMem->z = 0;
80307 return pColl->xCmp(pColl->pUser,pMem1->n,pMem1->z,pMem2->n,pMem2->z);
80335 static int isAllZero(const char *z, int n){
80338 if( z[i] ) return 0;
80364 if( !isAllZero(pB2->z, pB2->n) ) return -1;
80367 if( !isAllZero(pB1->z, pB1->n) ) return +1;
80371 c = memcmp(pB1->z, pB2->z, n1>n2 ? n2 : n1);
80664 mem1.z = (char*)&aKey1[d1];
80670 rc = memcmp(&aKey1[d1], pRhs->z, nCmp);
80698 rc = memcmp(&aKey1[d1], pRhs->z, nCmp);
80878 res = memcmp(&aKey1[szHdr], pPKey2->aMem[0].z, nCmp);
80984 (void)getVarint32((u8*)m.z, szHdr);
80995 (void)getVarint32((u8*)&m.z[szHdr-1], typeRowid);
81014 sqlite3VdbeSerialGet((u8*)&m.z[m.n-lenRowid], typeRowid, &v);
81064 *res = sqlite3VdbeRecordCompareWithSkip(m.n, m.z, pUnpacked, 0);
81471 assert( p->flags==MEM_Null && p->z==0 );
81475 return p->n ? p->z : 0;
81507 return (void*)p->z;
81621 const char *z, /* String pointer */
81626 if( sqlite3VdbeMemSetStr(pCtx->pOut, z, n, enc, xDel)==SQLITE_TOOBIG ){
81648 const void *z,
81654 setResultStrOrError(pCtx, z, n, 0, xDel);
81658 const void *z,
81665 (void)invokeValueDestructor(z, xDel, pCtx);
81667 setResultStrOrError(pCtx, z, (int)n, 0, xDel);
81674 SQLITE_API void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){
81677 sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);
81680 SQLITE_API void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){
81683 sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);
81718 const char *z,
81723 setResultStrOrError(pCtx, z, n, SQLITE_UTF8, xDel);
81727 const char *z,
81736 (void)invokeValueDestructor(z, xDel, pCtx);
81738 setResultStrOrError(pCtx, z, (int)n, enc, xDel);
81744 const void *z,
81749 setResultStrOrError(pCtx, z, n, SQLITE_UTF16NATIVE, xDel);
81753 const void *z,
81758 setResultStrOrError(pCtx, z, n, SQLITE_UTF16BE, xDel);
81762 const void *z,
81767 setResultStrOrError(pCtx, z, n, SQLITE_UTF16LE, xDel);
82103 pMem->z = 0;
82108 if( pMem->z ){
82109 memset(pMem->z, 0, nByte);
82112 return (void*)pMem->z;
82127 return (void*)p->pMem->z;
82770 rc = sqlite3_bind_blob(pStmt, i, pValue->z, pValue->n,SQLITE_TRANSIENT);
82775 rc = bindText(pStmt,i, pValue->z, pValue->n, SQLITE_TRANSIENT,
83002 char *z = 0;
83007 z = sqlite3VdbeExpandSql(p, zSql);
83010 return z;
83170 pUnpack = vdbeUnpackRecord(&p->keyinfo, pData->n, pData->z);
83255 *(const char**)pOut = p->aOp[ pScan->addrExplain ].p4.z;
83430 sqlite3VdbeMemSetStr(&utf8, pVar->z, pVar->n, enc, SQLITE_STATIC);
83442 while( nOut<pVar->n && (pVar->z[nOut]&0xc0)==0x80 ){ nOut++; }
83445 sqlite3_str_appendf(&out, "'%.*q'", nOut, pVar->z);
83465 sqlite3_str_appendf(&out, "%02x", pVar->z[i]&0xff);
83755 p->apCsr[iCur] = pCx = (VdbeCursor*)pMem->z;
83763 &pMem->z[ROUND8(sizeof(VdbeCursor))+2*sizeof(u32)*nField];
83790 if( sqlite3AtoF(pRec->z, &rValue, pRec->n, enc)==0 ) return;
83791 if( 0==sqlite3Atoi64(pRec->z, &iValue, pRec->n, enc) ){
83892 if( sqlite3AtoF(pMem->z, &pMem->u.r, pMem->n, pMem->enc)==0 ){
83895 if( sqlite3Atoi64(pMem->z, &pMem->u.i, pMem->n, pMem->enc)==0 ){
83948 sqlite3_snprintf(100, zCsr, "%02X", ((int)pMem->z[i] & 0xFF));
83952 char z = pMem->z[i];
83953 if( z<32 || z>126 ) *zCsr++ = '.';
83954 else *zCsr++ = z;
83982 u8 c = pMem->z[j];
84257 printf("%s\n", aOp[i].p4.z);
84619 if( pOp->p4.z ){
84620 p->zErrMsg = sqlite3MPrintf(db, "%z: %s", p->zErrMsg, pOp->p4.z);
84623 sqlite3VdbeError(p, "%s", pOp->p4.z);
84688 assert( pOp->p4.z!=0 );
84691 pOp->p1 = sqlite3Strlen30(pOp->p4.z);
84695 rc = sqlite3VdbeMemSetStr(pOut, pOp->p4.z, -1, SQLITE_UTF8, SQLITE_STATIC);
84699 assert( pOut->szMalloc>0 && pOut->zMalloc==pOut->z );
84704 sqlite3DbFree(db, pOp->p4.z);
84707 pOp->p4.z = pOut->z;
84731 assert( pOp->p4.z!=0 );
84734 pOut->z = pOp->p4.z;
84807 sqlite3VdbeMemSetStr(pOut, pOp->p4.z, pOp->p1, 0, 0);
84825 assert( pOp->p4.z==0 || pOp->p4.z==sqlite3VListNumToName(p->pVList,pOp->p1) );
85060 memcpy(pOut->z, pIn2->z, pIn2->n);
85062 memcpy(&pOut->z[pIn2->n], pIn1->z, pIn1->n);
85063 pOut->z[nByte]=0;
85064 pOut->z[nByte+1] = 0;
86103 pC->aRow = (u8*)pReg->z;
86180 zData = (u8*)sMem.z;
86273 pDest->z = pDest->zMalloc;
86275 memcpy(pDest->z, zData, len);
86276 pDest->z[len] = 0;
86277 pDest->z[len+1] = 0;
86303 sqlite3VdbeSerialGet((const u8*)pDest->z, t, pDest);
86335 zAffinity = pOp->p4.z;
86402 zAffinity = pOp->p4.z;
86497 pOut->z = pOut->zMalloc;
86508 zNewRecord = (u8 *)pOut->z;
86579 zName = pOp->p4.z;
87841 sqlite3VdbeRecordUnpack(pC->pKeyInfo, pIn3->n, pIn3->z, pIdxKey);
88222 x.pData = pData->z;
88920 x.pKey = pIn2->z;
89311 rc = sqlite3_exec(db, pOp->p4.z, 0, 0, 0);
89347 if( pOp->p4.z==0 ){
89363 db->aDb[iDb].zDbSName, zMaster, pOp->p4.z);
89419 sqlite3UnlinkAndDeleteTable(db, pOp->p1, pOp->p4.z);
89433 sqlite3UnlinkAndDeleteIndex(db, pOp->p1, pOp->p4.z);
89447 sqlite3UnlinkAndDeleteTrigger(db, pOp->p1, pOp->p4.z);
89476 char *z; /* Text of the error report */
89491 z = sqlite3BtreeIntegrityCheck(db->aDb[pOp->p5].pBt, &aRoot[1], nRoot,
89495 assert( z==0 );
89496 }else if( z==0 ){
89500 sqlite3VdbeMemSetStr(pIn1, z, -1, SQLITE_UTF8, sqlite3_free);
89524 sqlite3RowSetInsert((RowSet*)pIn1->z, pIn2->u.i);
89542 || sqlite3RowSetNext((RowSet*)pIn1->z, &val)==0
89598 exists = sqlite3RowSetTest((RowSet*)pIn1->z, iSet, pIn3->u.i);
89603 sqlite3RowSetInsert((RowSet*)pIn1->z, pIn3->u.i);
89686 pRt->z = (char*)pFrame;
89714 pFrame = (VdbeFrame*)pRt->z;
90282 pOut->z = (char *)sqlite3JournalModename(eNew);
90283 pOut->n = sqlite3Strlen30(pOut->z);
90387 const char *z = pOp->p4.z;
90388 sqlite3VdbeError(p, "database table is locked: %s", z);
90454 rc = sqlite3VtabCallDestroy(db, pOp->p1, pOp->p4.z);
90559 rc = pModule->xFilter(pVCur, iQuery, pOp->p4.z, nArg, apArg);
90699 rc = pVtab->pModule->xRename(pVtab, pName->z);
90988 assert( pOp->p4.z==0 || strncmp(pOp->p4.z, "-" "- ", 3)==0 );
90996 && (zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0
91001 char *z = sqlite3VdbeExpandSql(p, zTrace);
91002 x(db->pTraceArg, z);
91003 sqlite3_free(z);
91007 char *z = sqlite3MPrintf(db, "-- %s", zTrace);
91008 (void)db->xTrace(SQLITE_TRACE_STMT, db->pTraceArg, p, z);
91009 sqlite3DbFree(db, z);
91015 zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql);
91026 && (zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0
91585 void *z,
91638 rc = xCall(p->pCsr, iOffset+p->iOffset, n, z);
91656 SQLITE_API int sqlite3_blob_read(sqlite3_blob *pBlob, void *z, int n, int iOffset){
91657 return blobReadWrite(pBlob, z, n, iOffset, sqlite3BtreePayloadChecked);
91663 SQLITE_API int sqlite3_blob_write(sqlite3_blob *pBlob, const void *z, int n, int iOffset){
91664 return blobReadWrite(pBlob, (void *)z, n, iOffset, sqlite3BtreePutData);
92819 # define vdbeSorterBlockDebug(x,y,z)
93010 # define vdbeSorterExtendFile(x,y,z)
93496 getVarint32((const u8*)&pVal->z[1], t);
93582 memcpy(SRVAL(pNew), pVal->z, pVal->n);
94425 memcpy(pOut->z, pKey, nKey);
94478 *pRes = sqlite3VdbeRecordCompare(pVal->n, pVal->z, r2);
97652 if( op!=TK_INTEGER || pToken->z==0
97653 || sqlite3GetInt32(pToken->z, &iValue)==0 ){
97669 assert( pToken->z!=0 || pToken->n==0 );
97670 if( pToken->n ) memcpy(pNew->u.zToken, pToken->z, pToken->n);
97694 x.z = zToken;
97874 const char *z;
97879 z = pExpr->u.zToken;
97880 assert( z!=0 );
97881 assert( z[0]!=0 );
97882 assert( n==(u32)sqlite3Strlen30(z) );
97883 if( z[1]==0 ){
97885 assert( z[0]=='?' );
97889 if( z[0]=='?' ){
97895 i = z[1]-'0'; /* The common case of ?N for a single digit N */
97898 bOk = 0==sqlite3Atoi64(&z[1], &i, n-1, SQLITE_UTF8);
97921 x = (ynVar)sqlite3VListNameToNum(pParse->pVList, z, n);
97928 pParse->pVList = sqlite3VListAdd(db, pParse->pVList, z, n, x);
98604 pItem->zName = sqlite3DbStrNDup(pParse->db, pName->z, pName->n);
99082 SQLITE_PRIVATE int sqlite3IsRowid(const char *z){
99083 if( sqlite3StrICmp(z, "_ROWID_")==0 ) return 1;
99084 if( sqlite3StrICmp(z, "ROWID")==0 ) return 1;
99085 if( sqlite3StrICmp(z, "OID")==0 ) return 1;
100126 static void codeReal(Vdbe *v, const char *z, int negateFlag, int iMem){
100127 if( ALWAYS(z!=0) ){
100129 sqlite3AtoF(z, &value, sqlite3Strlen30(z), SQLITE_UTF8);
100154 const char *z = pExpr->u.zToken;
100155 assert( z!=0 );
100156 c = sqlite3DecOrHexToI64(z, &value);
100159 sqlite3ErrorMsg(pParse, "oversized integer: %s%s", negFlag ? "-" : "", z);
100162 if( sqlite3_strnicmp(z,"0x",2)==0 ){
100163 sqlite3ErrorMsg(pParse, "hex literal too big: %s%s", negFlag?"-":"",z);
100167 codeReal(v, z, negFlag, iMem);
100423 const char *z;
100428 z = &pExpr->u.zToken[2];
100429 n = sqlite3Strlen30(z) - 1;
100430 assert( z[n]=='\'' );
100431 zBlob = sqlite3HexToBlob(sqlite3VdbeDb(v), z, n);
100442 const char *z = sqlite3VListNumToName(pParse->pVList, pExpr->iColumn);
100443 assert( pExpr->u.zToken[0]=='?' || strcmp(pExpr->u.zToken, z)==0 );
100445 sqlite3VdbeAppendP4(v, (char*)z, P4_STATIC);
102699 zCol = sqlite3DbStrNDup(db, (char*)pColDef->z, pColDef->n);
102917 bQuote = sqlite3Isquote(pNew->z[0]);
103205 if( pToken->t.z>pBest->t.z ) pBest = pToken;
103326 assert( pToken->t.z>=zSql && &pToken->t.z[pToken->t.n]<=&zSql[nSql] );
103390 if( sqlite3IsIdChar(*pBest->t.z) ){
103398 iOff = pBest->t.z - zSql;
104867 char *z;
104877 z = zRet + sqlite3Strlen30(zRet);
104881 sqlite3_snprintf(24, z, " %llu", iVal);
104882 z += sqlite3Strlen30(z);
104885 assert( z[0]=='\0' && z>zRet );
104926 char *z = zRet;
104928 sqlite3_snprintf(24, z, "%llu ", (u64)aCnt[i]);
104929 z += sqlite3Strlen30(z);
104931 assert( z[0]=='\0' && z>zRet );
104932 z[-1] = '\0';
105388 char *z, *zDb;
105416 z = sqlite3NameFromToken(db, pTableName);
105417 if( z ){
105418 if( (pIdx = sqlite3FindIndex(db, z, zDb))!=0 ){
105420 }else if( (pTab = sqlite3LocateTable(pParse, 0, z, zDb))!=0 ){
105423 sqlite3DbFree(db, z);
105454 char *z = zIntArray;
105460 if( z==0 ) z = "";
105462 assert( z!=0 );
105464 for(i=0; *z && i<nOut; i++){
105466 while( (c=z[0])>='0' && c<='9' ){
105468 z++;
105479 if( *z==' ' ) z++;
105488 while( z[0] ){
105489 if( sqlite3_strglob("unordered*", z)==0 ){
105491 }else if( sqlite3_strglob("sz=[0-9]*", z)==0 ){
105492 pIndex->szIdxRow = sqlite3LogEst(sqlite3Atoi(z+3));
105493 }else if( sqlite3_strglob("noskipscan*", z)==0 ){
105497 else if( sqlite3_strglob("costmult=[0-9]*",z)==0 ){
105498 pIndex->pTable->costMult = sqlite3LogEst(sqlite3Atoi(z+9));
105501 while( z[0]!=0 && z[0]!=' ' ) z++;
105502 while( z[0]==' ' ) z++;
105522 const char *z;
105541 z = argv[2];
105557 decodeIntArray((char*)z, nCol, aiRowEst, pIndex->aiRowLogEst, pIndex);
105569 decodeIntArray((char*)z, 1, 0, &pTable->nRowLogEst, &fakeIdx);
106051 char *z = db->aDb[i].zDbSName;
106052 assert( z && zName );
106053 if( sqlite3StrICmp(z, zName)==0 ){
106686 char *z = sqlite3_mprintf("%s.%s", zTab, zCol);
106687 if( db->nDb>2 || iDb!=0 ) z = sqlite3_mprintf("%s.%z", zDb, z);
106688 sqlite3ErrorMsg(pParse, "access to %z is prohibited", z);
107547 zName = sqlite3DbStrNDup(db, (char*)pName->z, pName->n);
107936 char *z;
107945 z = sqlite3DbMallocRaw(db, pName->n + pType->n + 2);
107946 if( z==0 ) return;
107947 if( IN_RENAME_OBJECT ) sqlite3RenameTokenMap(pParse, (void*)z, pName);
107948 memcpy(z, pName->z, pName->n);
107949 z[pName->n] = 0;
107950 sqlite3Dequote(z);
107952 if( sqlite3_stricmp(z, p->aCol[i].zName)==0 ){
107953 sqlite3ErrorMsg(pParse, "duplicate column name: %s", z);
107954 sqlite3DbFree(db, z);
107962 sqlite3DbFree(db, z);
107969 pCol->zName = z;
107983 zType = z + sqlite3Strlen30(z) + 1;
107984 memcpy(zType, pType->z, pType->n);
108403 static int identLength(const char *z){
108405 for(n=0; *z; n++, z++){
108406 if( *z=='"' ){ n++; }
108424 static void identPut(char *z, int *pIdx, char *zSignedIdent){
108437 if( needQuote ) z[i++] = '"';
108439 z[i++] = zIdent[j];
108440 if( zIdent[j]=='"' ) z[i++] = '"';
108442 if( needQuote ) z[i++] = '"';
108443 z[i] = 0;
108972 n = (int)(pEnd2->z - pParse->sNameToken.z);
108973 if( pEnd2->z[0]!=';' ) n += pEnd2->n;
108975 "CREATE %s %.*s", zType2, n, pParse->sNameToken.z
109037 const char *zName = (const char *)pParse->sNameToken.z;
109040 if( pCons->z==0 ){
109043 nName = (int)((const char *)pCons->z - zName);
109066 const char *z;
109103 assert( sEnd.z[0]!=0 || sEnd.n==0 );
109104 if( sEnd.z[0]!=';' ){
109105 sEnd.z += sEnd.n;
109108 n = (int)(sEnd.z - pBegin->z);
109110 z = pBegin->z;
109111 while( sqlite3Isspace(z[n-1]) ){ n--; }
109112 sEnd.z = &z[n-1];
109638 char *z;
109672 z = (char*)&pFKey->aCol[nCol];
109673 pFKey->zTo = z;
109675 sqlite3RenameTokenMap(pParse, (void*)z, pTo);
109677 memcpy(z, pTo->z, pTo->n);
109678 z[pTo->n] = 0;
109679 sqlite3Dequote(z);
109680 z += pTo->n+1;
109707 pFKey->aCol[i].zCol = z;
109709 sqlite3RenameTokenRemap(pParse, z, pToCol->a[i].zName);
109711 memcpy(z, pToCol->a[i].zName, n);
109712 z[n] = 0;
109713 z += n+1;
109955 assert( pName && pName->z );
110039 assert( pName->z!=0 );
110399 int n = (int)(pParse->sLastToken.z - pName->z) + pParse->sLastToken.n;
110400 if( pName->z[n-1]==';' ) n--;
110403 onError==OE_None ? "" : " UNIQUE", n, pName->z);
110611 char *z;
110622 z = (char*)pArray;
110623 memset(&z[n * szEntry], 0, szEntry);
110835 if( pDatabase && pDatabase->z==0 ){
110930 Token *pToken = (ALWAYS(pDatabase) && pDatabase->z) ? pDatabase : pTable;
110963 if( pIndexedBy->n==1 && !pIndexedBy->z ){
111295 const char *z = pIndex->azColl[i];
111296 assert( z!=0 || pIndex->aiColumn[i]<0 );
111297 if( pIndex->aiColumn[i]>=0 && 0==sqlite3StrICmp(z, zColl) ){
111365 char *z; /* Name of a table or index */
111382 }else if( NEVER(pName2==0) || pName2->z==0 ){
111384 assert( pName1->z );
111397 z = sqlite3NameFromToken(db, pObjName);
111398 if( z==0 ) return;
111400 pTab = sqlite3FindTable(db, z, zDb);
111403 sqlite3DbFree(db, z);
111406 pIndex = sqlite3FindIndex(db, z, zDb);
111407 sqlite3DbFree(db, z);
111586 char *z = pColl->zName;
111590 pColl2 = sqlite3FindCollSeq(db, aEnc[i], z, 0);
111941 u8 *z;
111946 for(z=(u8*)pBest->zName; *z; z++) *z = sqlite3UpperToLower[*z];
113106 const unsigned char *z = sqlite3_value_text(argv[0]);
113109 if( z==0 ) return;
113110 z0 = z;
113111 while( (c = *z)!=0 ){
113112 z++;
113114 while( (*z & 0xc0)==0x80 ){ z++; z0++; }
113117 sqlite3_result_int(context, (int)(z-z0));
113272 const unsigned char *z;
113289 z = sqlite3_value_blob(argv[0]);
113290 if( z==0 ) return;
113293 z = sqlite3_value_text(argv[0]);
113294 if( z==0 ) return;
113297 for(z2=z; *z2; len++){
113340 while( *z && p1 ){
113341 SQLITE_SKIP_UTF8(z);
113344 for(z2=z; *z2 && p2; p2--){
113347 sqlite3_result_text64(context, (char*)z, z2-z, SQLITE_TRANSIENT,
113354 sqlite3_result_blob64(context, (char*)&z[p1], (u64)p2, SQLITE_TRANSIENT);
113404 char *z;
113411 z = 0;
113413 z = sqlite3Malloc(nByte);
113414 if( !z ){
113418 return z;
114043 char *z;
114047 z = contextMalloc(context, ((i64)i)+((i64)n)+3);
114048 if( z ){
114049 z[0] = '\'';
114051 z[j++] = zArg[i];
114053 z[j++] = '\'';
114056 z[j++] = '\'';
114057 z[j] = 0;
114058 sqlite3_result_text(context, z, j, sqlite3_free);
114079 const unsigned char *z = sqlite3_value_text(argv[0]);
114081 if( z && z[0] ) sqlite3_result_int(context, sqlite3Utf8Read(&z));
114094 unsigned char *z, *zOut;
114096 zOut = z = sqlite3_malloc64( argc*4+1 );
114097 if( z==0 ){
114123 sqlite3_result_text64(context, (char*)z, zOut-z, sqlite3_free, SQLITE_UTF8);
114137 char *zHex, *z;
114143 z = zHex = contextMalloc(context, ((i64)n)*2 + 1);
114147 *(z++) = hexdigits[(c>>4)&0xf];
114148 *(z++) = hexdigits[c&0xf];
114150 *z = 0;
114305 const unsigned char *z;
114306 for(z=zCharSet, nChar=0; *z; nChar++){
114307 SQLITE_SKIP_UTF8(z);
114315 for(z=zCharSet, nChar=0; *z; nChar++){
114316 azChar[nChar] = (unsigned char *)z;
114317 SQLITE_SKIP_UTF8(z);
114318 aLen[nChar] = (u8)(z - azChar[nChar]);
116305 tFrom.z = zFrom;
116427 const char *z = (p ? pFKey->pNextTo->zTo : pFKey->zTo);
116428 sqlite3HashInsert(&pTab->pSchema->fkeyHash, z, p);
121235 static u8 getSafetyLevel(const char *z, int omitFull, u8 dflt){
121243 if( sqlite3Isdigit(*z) ){
121244 return (u8)sqlite3Atoi(z);
121246 n = sqlite3Strlen30(z);
121248 if( iLength[i]==n && sqlite3StrNICmp(&zText[iOffset[i]],z,n)==0
121260 SQLITE_PRIVATE u8 sqlite3GetBoolean(const char *z, u8 dflt){
121261 return getSafetyLevel(z,1,dflt)!=0;
121273 static int getLockingMode(const char *z){
121274 if( z ){
121275 if( 0==sqlite3StrICmp(z, "exclusive") ) return PAGER_LOCKINGMODE_EXCLUSIVE;
121276 if( 0==sqlite3StrICmp(z, "normal") ) return PAGER_LOCKINGMODE_NORMAL;
121288 static int getAutoVacuum(const char *z){
121290 if( 0==sqlite3StrICmp(z, "none") ) return BTREE_AUTOVACUUM_NONE;
121291 if( 0==sqlite3StrICmp(z, "full") ) return BTREE_AUTOVACUUM_FULL;
121292 if( 0==sqlite3StrICmp(z, "incremental") ) return BTREE_AUTOVACUUM_INCR;
121293 i = sqlite3Atoi(z);
121304 static int getTempStore(const char *z){
121305 if( z[0]>='0' && z[0]<='2' ){
121306 return z[0] - '0';
121307 }else if( sqlite3StrICmp(z, "file")==0 ){
121309 }else if( sqlite3StrICmp(z, "memory")==0 ){
122657 assert( iDb==0 || pId2->z );
122658 if( pId2->z==0 ) iDb = -1;
122881 aOp[2].p4.z = "ok";
122883 aOp[5].p4.z = (char*)sqlite3ErrStr(SQLITE_CORRUPT);
123059 int iBt = (pId2->z?iDb:SQLITE_MAX_ATTACHED);
123727 char *z;
123729 z = sqlite3MPrintf(db, "malformed database schema (%s)", zObj);
123730 if( zExtra && zExtra[0] ) z = sqlite3MPrintf(db, "%z - %s", z, zExtra);
123731 *pData->pzErrMsg = z;
124545 const char *z = (const char*)zSql;
124546 for(sz=0; sz<nBytes && (z[sz]!=0 || z[sz+1]!=0); sz += 2){}
124863 && sqlite3StrNICmp((char*)p->z, &zKeyText[aKeyword[j].i], p->n)==0 ){
125985 char *z;
125987 case TK_ALL: z = "UNION ALL"; break;
125988 case TK_INTERSECT: z = "INTERSECT"; break;
125989 case TK_EXCEPT: z = "EXCEPT"; break;
125990 default: z = "UNION"; break;
125992 return z;
126021 # define explainTempTable(y,z)
126022 # define explainSetInteger(y,z)
126520 const char *z = pEList->a[i].zSpan;
126521 z = z==0 ? sqlite3MPrintf(db, "column%d", i+1) : sqlite3DbStrDup(db, z);
126522 sqlite3VdbeSetColName(v, i, COLNAME_NAME, z, SQLITE_DYNAMIC);
131289 char *z; /* A single column of result */
131313 z = sqlite3_mprintf("%s", colv[i]);
131314 if( z==0 ) goto malloc_failed;
131315 p->azResult[p->nData++] = z;
131331 z = 0;
131334 z = sqlite3_malloc64( n );
131335 if( z==0 ) goto malloc_failed;
131336 memcpy(z, argv[i], n);
131338 p->azResult[p->nData++] = z;
131765 char *z;
131771 z = sqlite3DbStrNDup(db, (char*)pAll->z, pAll->n);
131772 testcase( z==0 );
131776 pTrig->table, z);
131777 sqlite3DbFree(db, z);
131810 char *z = sqlite3DbSpanDup(db, zStart, zEnd);
131812 if( z ) for(i=0; z[i]; i++) if( sqlite3Isspace(z[i]) ) z[i] = ' ';
131813 return z;
131859 char *z = (char*)&pTriggerStep[1];
131860 memcpy(z, pName->z, pName->n);
131861 sqlite3Dequote(z);
131862 pTriggerStep->zTarget = z;
133943 char *z;
133947 z = sqlite3VMPrintf(db, zSql, ap);
133949 if( z==0 ) return SQLITE_NOMEM;
133950 rc = execSql(db, pzErrMsg, z);
133951 sqlite3DbFree(db, z);
134646 assert( (pParse->sNameToken.z==pName2->z && pName2->z!=0)
134647 || (pParse->sNameToken.z==pName1->z && pName2->z==0)
134650 &pModuleName->z[pModuleName->n] - pParse->sNameToken.z
134674 if( pParse->sArg.z && pParse->pNewTable ){
134675 const char *z = (const char*)pParse->sArg.z;
134678 addModuleArgument(pParse, pParse->pNewTable, sqlite3DbStrNDup(db, z, n));
134692 pParse->sArg.z = 0;
134710 pParse->sNameToken.n = (int)(pEnd->z - pParse->sNameToken.z) + pEnd->n;
134772 pParse->sArg.z = 0;
134782 if( pArg->z==0 ){
134783 pArg->z = p->z;
134786 assert(pArg->z <= p->z);
134787 pArg->n = (int)(&p->z[p->n] - pArg->z);
136238 const char *z = explainIndexColumnName(pIndex, i);
136240 sqlite3_str_appendf(pStr, i>=nSkip ? "%s=?" : "ANY(%s)", z);
138625 const u8 *z = 0; /* String on RHS of LIKE operator */
138652 z = sqlite3_value_text(pVal);
138657 z = (u8*)pRight->u.zToken;
138659 if( z ){
138663 while( (c=z[cnt])!=0 && c!=wc[0] && c!=wc[1] && c!=wc[2] ){
138665 if( c==wc[3] && z[cnt]!=0 ) cnt++;
138676 if( cnt!=0 && 255!=(u8)z[cnt-1] && (cnt>1 || z[0]!=wc[3]) ){
138680 *pisComplete = c==wc[0] && z[cnt+1]==0;
138683 pPrefix = sqlite3Expr(db, TK_STRING, (char*)z);
138741 z = 0;
138745 rc = (z!=0);
141851 char *z;
141853 z = sqlite3_mprintf("(%d,\"%s\",%x)",
141856 z = sqlite3_mprintf("(%d,%x)", p->u.vtab.idxNum, p->u.vtab.omitMask);
141858 sqlite3DebugPrintf(" %-19s", z);
141859 sqlite3_free(z);
146535 pWin->zBase = sqlite3DbStrNDup(pParse->db, pBase->z, pBase->n);
148252 memcpy(p->u.zToken, t.z, t.n);
148296 pIdToken->n, pIdToken->z);
151393 if( yymsp[0].minor.yy0.n==5 && sqlite3_strnicmp(yymsp[0].minor.yy0.z,"rowid",5)==0 ){
151397 … sqlite3ErrorMsg(pParse, "unknown table option: %.*s", yymsp[0].minor.yy0.n, yymsp[0].minor.yy0.z);
151407 {yymsp[1].minor.yy0.n = 0; yymsp[1].minor.yy0.z = 0;}
151411 …yymsp[-3].minor.yy0.n = (int)(&yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-3].minor.yy0.z);
151416 …yymsp[-5].minor.yy0.n = (int)(&yymsp[0].minor.yy0.z[yymsp[0].minor.yy0.n] - yymsp[-5].minor.yy0.z);
151420 {yymsp[-1].minor.yy0.n=yymsp[0].minor.yy0.n+(int)(yymsp[0].minor.yy0.z-yymsp[-1].minor.yy0.z);}
151425 yymsp[1].minor.yy294 = yyLookaheadToken.z;
151436 {sqlite3AddDefaultValue(pParse,yymsp[-1].minor.yy524,yymsp[-2].minor.yy0.z+1,yymsp[0].minor.yy0.z);}
151439 {sqlite3AddDefaultValue(pParse,yymsp[-1].minor.yy524,yymsp[-2].minor.yy0.z,yymsp[0].minor.yy294);}
151444 sqlite3AddDefaultValue(pParse,p,yymsp[-2].minor.yy0.z,yymsp[0].minor.yy294);
151454 sqlite3AddDefaultValue(pParse,p,yymsp[0].minor.yy0.z,yymsp[0].minor.yy0.z+yymsp[0].minor.yy0.n);
151790 {yymsp[1].minor.yy0.z=0; yymsp[1].minor.yy0.n=0;}
151856 {yymsp[-1].minor.yy0.z=0; yymsp[-1].minor.yy0.n=1;}
152011 if( !(yymsp[0].minor.yy0.z[0]=='#' && sqlite3Isdigit(yymsp[0].minor.yy0.z[1])) ){
152026 if( yymsp[0].minor.yy524 ) sqlite3GetInt32(&t.z[1], &yymsp[0].minor.yy524->iTable);
152343 all.z = yymsp[-3].minor.yy0.z;
152344 all.n = (int)(yymsp[0].minor.yy0.z - yymsp[-3].minor.yy0.z) + yymsp[0].minor.yy0.n;
152415 …or.yy434, yymsp[-1].minor.yy524, yymsp[-6].minor.yy494, yymsp[-7].minor.yy0.z, yymsp[0].minor.yy29…
152425 …ep(pParse, &yymsp[-3].minor.yy0, yymsp[-1].minor.yy524, yymsp[-5].minor.yy0.z, yymsp[0].minor.yy29…
152488 yymsp[-1].minor.yy0.n = (int)(pParse->sLastToken.z-yymsp[-1].minor.yy0.z) + pParse->sLastToken.n;
152552 …yymsp[-1].minor.yy295->zName = sqlite3DbStrNDup(pParse->db, yymsp[-4].minor.yy0.z, yymsp[-4].minor…
152652 …yylhsminor.yy295->zName = sqlite3DbStrNDup(pParse->db, yymsp[0].minor.yy0.z, yymsp[0].minor.yy0.n);
152783 if( TOKEN.z[0] ){
153326 static int keywordCode(const char *z, int n, int *pType){
153330 i = ((charMap(z[0])*4) ^ (charMap(z[n-1])*3) ^ n) % 127;
153336 while( j<n && (z[j]&~0x20)==zKW[j] ){ j++; }
153339 while( j<n && toupper(z[j])==zKW[j] ){ j++; }
153488 SQLITE_PRIVATE int sqlite3KeywordCode(const unsigned char *z, int n){
153490 keywordCode((char*)z, n, &id);
153556 const unsigned char *z = *pz;
153559 z += sqlite3GetToken(z, &t);
153570 *pz = z;
153604 static int analyzeWindowKeyword(const unsigned char *z){
153606 t = getToken(&z);
153608 t = getToken(&z);
153612 static int analyzeOverKeyword(const unsigned char *z, int lastToken){
153614 int t = getToken(&z);
153619 static int analyzeFilterKeyword(const unsigned char *z, int lastToken){
153620 if( lastToken==TK_RP && getToken(&z)==TK_LP ){
153631 SQLITE_PRIVATE int sqlite3GetToken(const unsigned char *z, int *tokenType){
153633 switch( aiClass[*z] ){ /* Switch on the character-class of the first byte
153637 testcase( z[0]==' ' );
153638 testcase( z[0]=='\t' );
153639 testcase( z[0]=='\n' );
153640 testcase( z[0]=='\f' );
153641 testcase( z[0]=='\r' );
153642 for(i=1; sqlite3Isspace(z[i]); i++){}
153647 if( z[1]=='-' ){
153648 for(i=2; (c=z[i])!=0 && c!='\n'; i++){}
153676 if( z[1]!='*' || z[2]==0 ){
153680 for(i=3, c=z[2]; (c!='*' || z[i]!='/') && (c=z[i])!=0; i++){}
153691 return 1 + (z[1]=='=');
153694 if( (c=z[1])=='=' ){
153709 if( (c=z[1])=='=' ){
153721 if( z[1]!='=' ){
153730 if( z[1]!='|' ){
153751 int delim = z[0];
153755 for(i=1; (c=z[i])!=0; i++){
153757 if( z[i+1]==delim ){
153777 if( !sqlite3Isdigit(z[1]) )
153787 testcase( z[0]=='0' ); testcase( z[0]=='1' ); testcase( z[0]=='2' );
153788 testcase( z[0]=='3' ); testcase( z[0]=='4' ); testcase( z[0]=='5' );
153789 testcase( z[0]=='6' ); testcase( z[0]=='7' ); testcase( z[0]=='8' );
153790 testcase( z[0]=='9' );
153793 if( z[0]=='0' && (z[1]=='x' || z[1]=='X') && sqlite3Isxdigit(z[2]) ){
153794 for(i=3; sqlite3Isxdigit(z[i]); i++){}
153798 for(i=0; sqlite3Isdigit(z[i]); i++){}
153800 if( z[i]=='.' ){
153802 while( sqlite3Isdigit(z[i]) ){ i++; }
153805 if( (z[i]=='e' || z[i]=='E') &&
153806 ( sqlite3Isdigit(z[i+1])
153807 || ((z[i+1]=='+' || z[i+1]=='-') && sqlite3Isdigit(z[i+2]))
153811 while( sqlite3Isdigit(z[i]) ){ i++; }
153815 while( IdChar(z[i]) ){
153822 for(i=1, c=z[0]; c!=']' && (c=z[i])!=0; i++){}
153828 for(i=1; sqlite3Isdigit(z[i]); i++){}
153834 testcase( z[0]=='$' ); testcase( z[0]=='@' );
153835 testcase( z[0]==':' ); testcase( z[0]=='#' );
153837 for(i=1; (c=z[i])!=0; i++){
153844 }while( (c=z[i])!=0 && !sqlite3Isspace(c) && c!=')' );
153851 }else if( c==':' && z[i+1]==':' ){
153862 for(i=1; aiClass[z[i]]<=CC_KYWD; i++){}
153863 if( IdChar(z[i]) ){
153871 return keywordCode((char*)z, i, tokenType);
153875 testcase( z[0]=='x' ); testcase( z[0]=='X' );
153876 if( z[1]=='\'' ){
153878 for(i=2; sqlite3Isxdigit(z[i]); i++){}
153879 if( z[i]!='\'' || i%2 ){
153881 while( z[i] && z[i]!='\'' ){ i++; }
153883 if( z[i] ) i++;
153903 while( IdChar(z[i]) ){ i++; }
154011 pParse->sLastToken.z = zSql;
155497 static int allSpaces(const char *z, int n){
155498 while( n>0 && z[n-1]==' ' ){ n--; }
157020 const char *z;
157029 z = sqlite3ErrStr(SQLITE_NOMEM_BKPT);
157032 z = db->errCode ? (char*)sqlite3_value_text(db->pErr) : 0;
157034 if( z==0 ){
157035 z = sqlite3ErrStr(db->errCode);
157039 return z;
157057 const void *z;
157066 z = (void *)outOfMem;
157068 z = sqlite3_value_text16(db->pErr);
157069 if( z==0 ){
157071 z = sqlite3_value_text16(db->pErr);
157081 return z;
157473 const char *z;
157511 for(i=0; aMode[i].z; i++){
157512 const char *z = aMode[i].z;
157513 if( nVal==sqlite3Strlen30(z) && 0==memcmp(zVal, z, nVal) ){
158755 const char *z = sqlite3_uri_parameter(zFilename, zParam);
158757 return z ? sqlite3GetBoolean(z, bDflt) : bDflt;
158768 const char *z = sqlite3_uri_parameter(zFilename, zParam);
158770 if( z && sqlite3DecOrHexToI64(z, &v)==0 ){
160298 char *z; /* Text of the token */
160411 # define sqlite3Fts3DeferToken(x,y,z) SQLITE_OK
160414 # define sqlite3Fts3DeferredTokenList(x,y,z) SQLITE_OK
160688 SQLITE_PRIVATE void sqlite3Fts3Dequote(char *z){
160691 quote = z[0];
160699 while( z[iIn] ){
160700 if( z[iIn]==quote ){
160701 if( z[iIn+1]!=quote ) break;
160702 z[iOut++] = quote;
160705 z[iOut++] = z[iIn++];
160708 z[iOut] = '\0';
160924 char *z = p->azColumn[i];
160925 zContentCols = sqlite3_mprintf("%z, 'c%d%q'", zContentCols, i, z);
161012 const char *z,
161017 const char *zCsr = z;
161024 *pnKey = (int)(zCsr-z);
161044 char *z;
161046 z = sqlite3_vmprintf(zFormat, ap);
161048 if( z && *pz ){
161049 char *z2 = sqlite3_mprintf("%s%s", *pz, z);
161050 sqlite3_free(z);
161051 z = z2;
161053 if( z==0 ) *pRc = SQLITE_NOMEM;
161055 *pz = z;
161076 char *z = zRet;
161077 *(z++) = '"';
161079 if( zInput[i]=='"' ) *(z++) = '"';
161080 *(z++) = zInput[i];
161082 *(z++) = '"';
161083 *(z++) = '\0';
161454 char const *z = argv[i];
161460 && strlen(z)>8
161461 && 0==sqlite3_strnicmp(z, "tokenize", 8)
161462 && 0==sqlite3Fts3IsIdChar(z[8])
161464 rc = sqlite3Fts3InitTokenizer(pHash, &z[9], &pTokenizer, pzErr);
161468 else if( isFts4 && fts3IsSpecialColumn(z, &nKey, &zVal) ){
161489 if( nKey==pOp->nOpt && !sqlite3_strnicmp(z, pOp->zOpt, pOp->nOpt) ){
161550 sqlite3Fts3ErrMsg(pzErr, "unrecognized parameter: %s", z);
161560 nString += (int)(strlen(z) + 1);
161561 aCol[nCol++] = z;
161670 char *z;
161672 z = (char *)sqlite3Fts3NextToken(aCol[iCol], &n);
161674 memcpy(zCsr, z, n);
163356 filter.zTerm = pTok->z;
164335 pToken->z, pToken->n, pToken->isPrefix, &pToken->pSegcsr
164609 rc = sqlite3Fts3MsrIncrStart(pTab, pSegcsr, iCol, pToken->z, pToken->n);
166951 const char *z,
166959 rc = pModule->xOpen(pTokenizer, z, n, &pCsr);
166996 const char *z, int n, /* Input string */
167009 if( sqlite3_fts3_enable_parentheses && (z[i]=='(' || z[i]==')') ) break;
167010 if( z[i]=='"' ) break;
167014 rc = sqlite3Fts3OpenTokenizer(pTokenizer, pParse->iLangid, z, i, &pCursor);
167032 pRet->pPhrase->aToken[0].z = (char *)&pRet->pPhrase[1];
167033 memcpy(pRet->pPhrase->aToken[0].z, zToken, nToken);
167035 if( iEnd<n && z[iEnd]=='*' ){
167042 && iStart>0 && z[iStart-1]=='-'
167046 }else if( pParse->bFts4 && iStart>0 && z[iStart-1]=='^' ){
167183 p->pPhrase->aToken[jj].z = zBuf;
167212 const char *z, int n, /* Input string */
167217 char *z; /* Keyword text */
167233 const char *zInput = z;
167257 if( nInput>=pKey->n && 0==memcmp(zInput, pKey->z, pKey->n) ){
167288 *pnConsumed = (int)((zInput - z) + nKey);
167305 *pnConsumed = (int)((zInput - z) + ii + 1);
167317 *pnConsumed = (int)(zInput - z) + 1 + nConsumed;
167321 *pnConsumed = (int)((zInput - z) + 1);
167347 iColLen = (int)((zInput - z) + nStr + 1);
167351 rc = getNextToken(pParse, iCol, &z[iColLen], n-iColLen, ppExpr, pnConsumed);
167429 const char *z, int n, /* Text of MATCH query */
167437 const char *zIn = z;
167783 const char *z, int n, /* Text of MATCH query */
167797 if( z==0 ){
167802 n = (int)strlen(z);
167804 rc = fts3ExprParse(&sParse, z, n, ppExpr, &nParsed);
167846 const char *z, int n, /* Text of MATCH query */
167851 pTokenizer, iLangid, azCol, bFts4, nCol, iDefaultCol, z, n, ppExpr
167873 sqlite3Fts3ErrMsg(pzErr, "malformed MATCH expression: [%s]", z);
167949 pPhrase->aToken[i].n, pPhrase->aToken[i].z,
168209 const char *z = (const char *)pKey;
168211 if( nKey<=0 ) nKey = (int) strlen(z);
168213 h = (h<<3) ^ h ^ *z++;
168228 const char *z = (const char *)pKey;
168230 h = (h<<3) ^ h ^ *(z++);
168647 static int isConsonant(const char *z){
168649 char x = *z;
168654 return z[1]==0 || isVowel(z + 1);
168656 static int isVowel(const char *z){
168658 char x = *z;
168663 return isConsonant(z + 1);
168685 static int m_gt_0(const char *z){
168686 while( isVowel(z) ){ z++; }
168687 if( *z==0 ) return 0;
168688 while( isConsonant(z) ){ z++; }
168689 return *z!=0;
168695 static int m_eq_1(const char *z){
168696 while( isVowel(z) ){ z++; }
168697 if( *z==0 ) return 0;
168698 while( isConsonant(z) ){ z++; }
168699 if( *z==0 ) return 0;
168700 while( isVowel(z) ){ z++; }
168701 if( *z==0 ) return 1;
168702 while( isConsonant(z) ){ z++; }
168703 return *z==0;
168709 static int m_gt_1(const char *z){
168710 while( isVowel(z) ){ z++; }
168711 if( *z==0 ) return 0;
168712 while( isConsonant(z) ){ z++; }
168713 if( *z==0 ) return 0;
168714 while( isVowel(z) ){ z++; }
168715 if( *z==0 ) return 0;
168716 while( isConsonant(z) ){ z++; }
168717 return *z!=0;
168723 static int hasVowel(const char *z){
168724 while( isConsonant(z) ){ z++; }
168725 return *z!=0;
168734 static int doubleConsonant(const char *z){
168735 return isConsonant(z) && z[0]==z[1];
168746 static int star_oh(const char *z){
168748 isConsonant(z) &&
168749 z[0]!='w' && z[0]!='x' && z[0]!='y' &&
168750 isVowel(z+1) &&
168751 isConsonant(z+2);
168772 char *z = *pz;
168773 while( *zFrom && *zFrom==*z ){ z++; zFrom++; }
168775 if( xCond && !xCond(z) ) return 1;
168777 *(--z) = *(zTo++);
168779 *pz = z;
168841 char *z, *z2;
168862 z = &zReverse[j+1];
168866 if( z[0]=='s' ){
168868 !stem(&z, "sess", "ss", 0) &&
168869 !stem(&z, "sei", "i", 0) &&
168870 !stem(&z, "ss", "ss", 0)
168872 z++;
168877 z2 = z;
168878 if( stem(&z, "dee", "ee", m_gt_0) ){
168881 (stem(&z, "gni", "", hasVowel) || stem(&z, "de", "", hasVowel))
168882 && z!=z2
168884 if( stem(&z, "ta", "ate", 0) ||
168885 stem(&z, "lb", "ble", 0) ||
168886 stem(&z, "zi", "ize", 0) ){
168888 }else if( doubleConsonant(z) && (*z!='l' && *z!='s' && *z!='z') ){
168889 z++;
168890 }else if( m_eq_1(z) && star_oh(z) ){
168891 *(--z) = 'e';
168896 if( z[0]=='y' && hasVowel(z+1) ){
168897 z[0] = 'i';
168901 switch( z[1] ){
168903 if( !stem(&z, "lanoita", "ate", m_gt_0) ){
168904 stem(&z, "lanoit", "tion", m_gt_0);
168908 if( !stem(&z, "icne", "ence", m_gt_0) ){
168909 stem(&z, "icna", "ance", m_gt_0);
168913 stem(&z, "rezi", "ize", m_gt_0);
168916 stem(&z, "igol", "log", m_gt_0);
168919 if( !stem(&z, "ilb", "ble", m_gt_0)
168920 && !stem(&z, "illa", "al", m_gt_0)
168921 && !stem(&z, "iltne", "ent", m_gt_0)
168922 && !stem(&z, "ile", "e", m_gt_0)
168924 stem(&z, "ilsuo", "ous", m_gt_0);
168928 if( !stem(&z, "noitazi", "ize", m_gt_0)
168929 && !stem(&z, "noita", "ate", m_gt_0)
168931 stem(&z, "rota", "ate", m_gt_0);
168935 if( !stem(&z, "msila", "al", m_gt_0)
168936 && !stem(&z, "ssenevi", "ive", m_gt_0)
168937 && !stem(&z, "ssenluf", "ful", m_gt_0)
168939 stem(&z, "ssensuo", "ous", m_gt_0);
168943 if( !stem(&z, "itila", "al", m_gt_0)
168944 && !stem(&z, "itivi", "ive", m_gt_0)
168946 stem(&z, "itilib", "ble", m_gt_0);
168952 switch( z[0] ){
168954 if( !stem(&z, "etaci", "ic", m_gt_0)
168955 && !stem(&z, "evita", "", m_gt_0)
168957 stem(&z, "ezila", "al", m_gt_0);
168961 stem(&z, "itici", "ic", m_gt_0);
168964 if( !stem(&z, "laci", "ic", m_gt_0) ){
168965 stem(&z, "luf", "", m_gt_0);
168969 stem(&z, "ssen", "", m_gt_0);
168974 switch( z[1] ){
168976 if( z[0]=='l' && m_gt_1(z+2) ){
168977 z += 2;
168981 if( z[0]=='e' && z[2]=='n' && (z[3]=='a' || z[3]=='e') && m_gt_1(z+4) ){
168982 z += 4;
168986 if( z[0]=='r' && m_gt_1(z+2) ){
168987 z += 2;
168991 if( z[0]=='c' && m_gt_1(z+2) ){
168992 z += 2;
168996 if( z[0]=='e' && z[2]=='b' && (z[3]=='a' || z[3]=='i') && m_gt_1(z+4) ){
168997 z += 4;
169001 if( z[0]=='t' ){
169002 if( z[2]=='a' ){
169003 if( m_gt_1(z+3) ){
169004 z += 3;
169006 }else if( z[2]=='e' ){
169007 if( !stem(&z, "tneme", "", m_gt_1)
169008 && !stem(&z, "tnem", "", m_gt_1)
169010 stem(&z, "tne", "", m_gt_1);
169016 if( z[0]=='u' ){
169017 if( m_gt_1(z+2) ){
169018 z += 2;
169020 }else if( z[3]=='s' || z[3]=='t' ){
169021 stem(&z, "noi", "", m_gt_1);
169025 if( z[0]=='m' && z[2]=='i' && m_gt_1(z+3) ){
169026 z += 3;
169030 if( !stem(&z, "eta", "", m_gt_1) ){
169031 stem(&z, "iti", "", m_gt_1);
169035 if( z[0]=='s' && z[2]=='o' && m_gt_1(z+3) ){
169036 z += 3;
169041 if( z[0]=='e' && z[2]=='i' && m_gt_1(z+3) ){
169042 z += 3;
169048 if( z[0]=='e' ){
169049 if( m_gt_1(z+1) ){
169050 z++;
169051 }else if( m_eq_1(z+1) && !star_oh(z+1) ){
169052 z++;
169057 if( m_gt_1(z) && z[0]=='l' && z[1]=='l' ){
169058 z++;
169064 *pnOut = i = (int)strlen(z);
169066 while( *z ){
169067 zOut[--i] = *(z++);
169100 const char *z = c->zInput;
169106 while( c->iOffset<c->nInput && isDelim(z[c->iOffset]) ){
169112 while( c->iOffset<c->nInput && !isDelim(z[c->iOffset]) ){
169125 porter_stemmer(&z[iStartOffset], n, c->zToken, pnBytes);
169334 char *z = (char *)zArg;
169344 z = (char *)sqlite3Fts3NextToken(zCopy, &n);
169345 if( z==0 ){
169347 z = zCopy;
169349 z[n] = '\0';
169350 sqlite3Fts3Dequote(z);
169352 m = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash,z,(int)strlen(z)+1);
169354 sqlite3Fts3ErrMsg(pzErr, "unknown tokenizer: %s", z);
169359 z = &z[n+1];
169360 while( z<zEnd && (NULL!=(z = (char *)sqlite3Fts3NextToken(z, &n))) ){
169369 aArg[iArg++] = z;
169370 z[n] = '\0';
169371 sqlite3Fts3Dequote(z);
169372 z = &z[n+1];
172292 char *z, /* Pointer to buffer containing block data */
172299 sqlite3_bind_blob(pStmt, 2, z, n, SQLITE_STATIC);
173938 const char *z = (const char *) sqlite3_column_text(pStmt, iCol+1);
173939 rc = fts3PendingTermsAdd(p, iLangid, z, iCol, &aSz[iCol]);
175377 const char *z = *pz;
175379 while( (*z)>='0' && (*z)<='9' && i<214748363 ) i = 10*i + *(z++) - '0';
175380 *pz = z;
175400 const char *z = zParam;
175403 nMerge = fts3Getint(&z);
175407 if( z[0]==',' && z[1]!='\0' ){
175408 z++;
175409 nMin = fts3Getint(&z);
175412 if( z[0]!='\0' || nMin<2 ){
175803 && (0==memcmp(zToken, pPT->z, pPT->n))
176213 char *z; /* Pointer to buffer containing string */
176709 char *zNew = sqlite3_realloc64(pStr->z, nAlloc);
176713 pStr->z = zNew;
176716 assert( pStr->z!=0 && (pStr->nAlloc >= pStr->n+nAppend+1) );
176719 memcpy(&pStr->z[pStr->n], zAppend, nAppend);
176721 pStr->z[pStr->n] = '\0';
177603 sqlite3_free(res.z);
177605 sqlite3_result_text(pCtx, res.z, -1, sqlite3_free);
177787 sqlite3_free(res.z);
177789 sqlite3_result_text(pCtx, res.z, res.n-1, sqlite3_free);
177961 const unsigned char *z = (const unsigned char *)zIn;
177962 const unsigned char *zTerm = &z[nIn];
177968 while( z<zTerm ){
177969 READ_UTF8(z, zTerm, iCode);
177986 z = (const unsigned char *)zIn;
177987 while( z<zTerm ){
177988 READ_UTF8(z, zTerm, iCode);
178057 const char *z = azArg[i];
178058 int n = (int)strlen(z);
178060 if( n==19 && memcmp("remove_diacritics=1", z, 19)==0 ){
178063 else if( n==19 && memcmp("remove_diacritics=0", z, 19)==0 ){
178066 else if( n==19 && memcmp("remove_diacritics=2", z, 19)==0 ){
178069 else if( n>=11 && memcmp("tokenchars=", z, 11)==0 ){
178070 rc = unicodeAddExceptions(pNew, 1, &z[11], n-11);
178072 else if( n>=11 && memcmp("separators=", z, 11)==0 ){
178073 rc = unicodeAddExceptions(pNew, 0, &z[11], n-11);
178150 const unsigned char *z = &pCsr->aInput[pCsr->iOff];
178151 const unsigned char *zStart = z;
178158 while( z<zTerm ){
178159 READ_UTF8(z, zTerm, iCode);
178161 zStart = z;
178179 zEnd = z;
178186 if( z>=zTerm ) break;
178187 READ_UTF8(z, zTerm, iCode);
178193 pCsr->iOff = (int)(z - pCsr->aInput);
178958 const char *z = (const char*)sqlite3_value_text(pValue);
178960 jsonAppendRaw(p, z, n);
178964 const char *z = (const char*)sqlite3_value_text(pValue);
178967 jsonAppendRaw(p, z, n);
178969 jsonAppendString(p, z, n);
179158 const char *z = pNode->u.zJContent;
179159 if( z[0]=='-' ){ z++; }
179160 while( z[0]>='0' && z[0]<='9' ){
179161 unsigned v = *(z++) - '0';
179164 if( z[0]>='0' && z[0]<='9' ) goto int_as_real;
179186 const char *z = pNode->u.zJContent;
179187 sqlite3AtoF(z, &r, sqlite3Strlen30(z), SQLITE_UTF8);
179212 const char *z = pNode->u.zJContent;
179221 char c = z[i];
179225 c = z[++i];
179230 c = z[i+1];
179340 static int jsonIs4Hex(const char *z){
179342 for(i=0; i<4; i++) if( !safe_isxdigit(z[i]) ) return 0;
179360 const char *z = pParse->zJson;
179361 while( safe_isspace(z[i]) ){ i++; }
179362 if( (c = z[i])=='{' ){
179367 while( safe_isspace(z[j]) ){ j++; }
179380 while( safe_isspace(z[j]) ){ j++; }
179381 if( z[j]!=':' ) return -1;
179387 while( safe_isspace(z[j]) ){ j++; }
179388 c = z[j];
179400 while( safe_isspace(z[j]) ){ j++; }
179409 while( safe_isspace(z[j]) ){ j++; }
179410 c = z[j];
179422 c = z[j];
179428 c = z[++j];
179431 || (c=='u' && jsonIs4Hex(z+j+1)) ){
179441 jsonParseAddNode(pParse, JSON_STRING, j+1-i, &z[i]);
179445 && strncmp(z+i,"null",4)==0
179446 && !safe_isalnum(z[i+4]) ){
179450 && strncmp(z+i,"true",4)==0
179451 && !safe_isalnum(z[i+4]) ){
179455 && strncmp(z+i,"false",5)==0
179456 && !safe_isalnum(z[i+5]) ){
179466 if( z[j]=='0' && z[j+1]>='0' && z[j+1]<='9' ) return -1;
179470 c = z[j];
179473 if( z[j-1]=='-' ) return -1;
179479 if( z[j-1]<'0' ) return -1;
179482 c = z[j+1];
179485 c = z[j+1];
179492 if( z[j-1]<'0' ) return -1;
179494 j - i, &z[i]);
180207 const char *z;
180224 z = (const char*)sqlite3_value_text(argv[i]);
180226 jsonAppendString(&jx, z, n);
180481 char *z;
180491 z = pStr->zBuf;
180492 for(i=1; z[i]!=',' || inStr; i++){
180494 if( z[i]=='"' ){
180496 }else if( z[i]=='\\' ){
180501 memmove(&z[1], &z[i+1], (size_t)pStr->nUsed-1);
180519 const char *z;
180531 z = (const char*)sqlite3_value_text(argv[0]);
180533 jsonAppendString(pStr, z, n);
180926 const char *z;
180934 z = (const char*)sqlite3_value_text(argv[0]);
180935 if( z==0 ) return SQLITE_OK;
180939 memcpy(p->zJson, z, (size_t)n+1);
185017 char *z;
185021 z = sqlite3_vmprintf(zFmt, ap);
185024 if( z==0 ){
185027 pCheck->rc = sqlite3_prepare_v2(pCheck->db, z, -1, &pRet, 0);
185031 sqlite3_free(z);
185045 char *z = sqlite3_vmprintf(zFmt, ap);
185046 if( z==0 ){
185050 pCheck->zReport, (pCheck->zReport ? "\n" : ""), z
185582 const unsigned char *z; /* Unparsed input */
185601 while( safe_isspace(p->z[0]) ) p->z++;
185602 return p->z[0];
185610 const unsigned char *z = p->z;
185616 c = z[j];
185618 if( c=='0' && z[j+1]>='0' && z[j+1]<='9' ) return 0;
185620 c = z[j];
185623 if( z[j-1]=='-' ) return 0;
185629 if( z[j-1]<'0' ) return 0;
185632 c = z[j+1];
185635 c = z[j+1];
185642 if( z[j-1]<'0' ) return 0;
185648 (void)sqlite3AtoF((const char*)p->z, &r, j, SQLITE_UTF8);
185651 *pVal = (GeoCoord)atof((const char*)p->z);
185654 p->z += j;
185666 static GeoPoly *geopolyParseJson(const unsigned char *z, int *pRc){
185670 s.z = z;
185672 s.z++;
185676 s.z++;
185692 s.z++;
185700 s.z++;
185709 && (s.z++, geopolySkipSpace(&s)==0)
185864 const char *z = (const char*)sqlite3_value_text(argv[i]);
185865 if( z && z[0] ){
185866 sqlite3_str_appendf(x, " %s", z);
189344 unsigned char *z = (unsigned char*)*pz;
189345 unsigned char *zStart = z;
189346 while( (c = zValue[0x7f&*(z++)])>=0 ){
189349 z--;
189350 *pLen -= z - zStart;
189351 *pz = (char*)z;
189360 const unsigned char *z = (const unsigned char *)zIn;
189366 sum0 += ((unsigned)z[0] + z[4] + z[8] + z[12]);
189367 sum1 += ((unsigned)z[1] + z[5] + z[9] + z[13]);
189368 sum2 += ((unsigned)z[2] + z[6] + z[10]+ z[14]);
189369 sum3 += ((unsigned)z[3] + z[7] + z[11]+ z[15]);
189370 z += 16;
189374 sum0 += z[0];
189375 sum1 += z[1];
189376 sum2 += z[2];
189377 sum3 += z[3];
189378 z += 4;
189383 case 3: sum3 += (z[2] << 8);
189384 case 2: sum3 += (z[1] << 16);
189385 case 1: sum3 += (z[0] << 24);
190274 const char *z = pIter->azTblCol[i];
190275 zList = rbuMPrintf(p, "%z%s\"%w\"", zList, zSep, z);
190596 char *z = 0;
190625 z = rbuMPrintf(p, "%z%s\"%w\"%s", z, zSep, zCol, zDesc);
190629 z = rbuMPrintf(p, "%z)", z);
190632 return z;
191483 static void rbuFileSuffix3(const char *zBase, char *z){
191490 sz = (int)strlen(z)&0xffffff;
191491 for(i=sz-1; i>0 && z[i]!='/' && z[i]!='.'; i--){}
191492 if( z[i]=='.' && sz>i+4 ) memmove(&z[i+1], &z[sz-3], 4);
191826 const unsigned char *z = sqlite3_column_text(p->objiter.pSelect, iCol);
191827 if( z==0 ){
191830 *pzMask = (const char*)z;
191856 # define assertColumnName(x,y,z)
193496 const char *z = &zName[n];
193500 if( z[0]==0 ){
193502 if( odd && z[1]==0 ) break;
193504 z++;
193506 z += 2;
193508 while( *z==0 ) z++;
193510 z += (n + 8 + 1);
193511 return z;
194342 char *z;
194365 pCsr->aPage[0].zPath = z = sqlite3_mprintf("/");
194367 if( z==0 ) rc = SQLITE_NOMEM_BKPT;
194390 pCsr->zPath = z = sqlite3_mprintf(
194402 return z==0 ? SQLITE_NOMEM_BKPT : SQLITE_OK;
194428 p[1].zPath = z = sqlite3_mprintf("%s%.3x/", p->zPath, p->iCell);
194430 if( z==0 ) rc = SQLITE_NOMEM_BKPT;
194463 pCsr->zPath = z = sqlite3_mprintf("%s", p->zPath);
194464 if( z==0 ) rc = SQLITE_NOMEM_BKPT;
195434 u8 *z;
195440 z = (u8 *)sqlite3_value_text(pValue);
195442 z = (u8 *)sqlite3_value_blob(pValue);
195445 if( z==0 && (eType!=SQLITE_BLOB || n>0) ) return SQLITE_NOMEM;
195450 if( n ) memcpy(&aBuf[nVarint + 1], z, n);
195497 static unsigned int sessionHashAppendBlob(unsigned int h, int n, const u8 *z){
195499 for(i=0; i<n; i++) h = HASH_APPEND(h, z[i]);
195560 const u8 *z;
195563 z = (const u8 *)sqlite3_value_text(pVal);
195565 z = (const u8 *)sqlite3_value_blob(pVal);
195568 if( !z && (eType!=SQLITE_BLOB || n>0) ) return SQLITE_NOMEM;
195569 h = sessionHashAppendBlob(h, n, z);
195905 const u8 *z;
195909 z = sqlite3_value_text(pVal);
195911 z = sqlite3_value_blob(pVal);
195913 if( n>0 && memcmp(a, z, n) ) return 0;
197045 u8 *z;
197048 z = (u8 *)sqlite3_column_blob(pStmt, iCol);
197050 z = (u8 *)sqlite3_column_text(pStmt, iCol);
197053 if( z || (eType==SQLITE_BLOB && nByte==0) ){
197055 sessionAppendBlob(p, z, nByte, pRc);
198799 if( (eType==SQLITE_TEXT || eType==SQLITE_BLOB) && pVal->z==0 ){
201318 static void sqlite3Fts5Dequote(char *z);
203529 const char *z, int n
203531 if( *pRc==SQLITE_OK && z ){
203532 if( n<0 ) n = (int)strlen(z);
203533 p->zOut = sqlite3_mprintf("%z%.*s", p->zOut, n, z);
204647 static int fts5Dequote(char *z){
204651 q = z[0];
204657 while( ALWAYS(z[iIn]) ){
204658 if( z[iIn]==q ){
204659 if( z[iIn+1]!=q ){
204668 z[iOut++] = q;
204671 z[iOut++] = z[iIn++];
204675 z[iOut] = '\0';
204692 static void sqlite3Fts5Dequote(char *z){
204695 assert( 0==fts5_iswhitespace(z[0]) );
204696 quote = z[0];
204698 fts5Dequote(z);
205061 const char *z;
205067 z = fts5ConfigGobbleWord(&rc, zOrig, &zOne, &bMustBeCol);
205068 z = fts5ConfigSkipWhitespace(z);
205069 if( z && *z=='=' ){
205071 z++;
205072 if( bMustBeCol ) z = 0;
205074 z = fts5ConfigSkipWhitespace(z);
205075 if( z && z[0] ){
205077 z = fts5ConfigGobbleWord(&rc, z, &zTwo, &bDummy);
205078 if( z && z[0] ) z = 0;
205082 if( z==0 ){
205621 const char *z = *pz;
205625 while( fts5ExprIsspace(*z) ) z++;
205627 pToken->p = z;
205629 switch( *z ){
205646 for(z2=&z[1]; 1; z2++){
205656 pToken->n = (z2 - z);
205662 if( sqlite3Fts5IsBareword(z[0])==0 ){
205663 sqlite3Fts5ParseError(pParse, "fts5: syntax error near \"%.1s\"", z);
205667 for(z2=&z[1]; sqlite3Fts5IsBareword(*z2); z2++);
205668 pToken->n = (z2 - z);
205692 const char *z = zExpr;
205705 t = fts5ExprGetToken(&sParse, &z, &token);
207108 char *z = 0;
207113 rc = fts5ParseStringFromToken(pToken, &z);
207117 sqlite3Fts5Dequote(z);
207118 n = (int)strlen(z);
207119 rc = sqlite3Fts5Tokenize(pConfig, flags, z, n, &sCtx, fts5ParseTokenize);
207121 sqlite3_free(z);
207370 char *z; /* Dequoted copy of token p */
207372 z = sqlite3Fts5Strndup(&pParse->rc, p->p, p->n);
207375 sqlite3Fts5Dequote(z);
207377 if( 0==sqlite3_stricmp(pConfig->azCol[iCol], z) ) break;
207380 sqlite3Fts5ParseError(pParse, "no such column: %s", z);
207384 sqlite3_free(z);
207810 char *z = fts5ExprPrintTcl(pConfig, zNearsetCmd, pExpr->apChild[i]);
207811 if( !z ){
207815 zRet = fts5PrintfAppend(zRet, " [%z]", z);
207882 char *z = fts5ExprPrint(pConfig, pExpr->apChild[i]);
207883 if( z==0 ){
207891 (b?"(":""), z, (b?")":"")
208053 const char *z;
208067 rc = sqlite3_create_function(db, p->z, -1, SQLITE_UTF8, pCtx, p->x, 0, 0);
208199 const char *z, int n
208220 FTS5_TOKENIZE_DOCUMENT, z, n, (void*)&sCtx, fts5ExprPopulatePoslistsCb
211342 const u8 *z = 0;
211353 sqlite3Fts5HashScanEntry(p->pHash, (const char**)&z, &pList, &nList);
211354 n = (z ? (int)strlen((const char*)z) : 0);
211368 z = pTerm;
211374 sqlite3Fts5BufferSet(&p->rc, &pIter->term, n, z);
212621 const char *z = (pWriter->btterm.n>0?(const char*)pWriter->btterm.p:"");
212624 sqlite3_bind_blob(p->pIdxWriter, 2, z, pWriter->btterm.n, SQLITE_STATIC);
214386 const char *z = (const char*)fts5MultiIterTerm((Fts5Iter*)pIndexIter, &n);
214388 return &z[1];
214556 const char *z, /* Index key to query for */
214564 int rc = sqlite3Fts5IndexQuery(p, z, n, flags, 0, &pIter);
214570 cksum ^= sqlite3Fts5IndexEntryCksum(rowid, 0, 0, iIdx, z, n);
214579 cksum ^= sqlite3Fts5IndexEntryCksum(rowid, iCol, iOff, iIdx, z, n);
214600 const char *z, int n, /* Possibly new term to test */
214606 fts5BufferSet(&rc, pPrev, n, (const u8*)z);
214608 if( rc==SQLITE_OK && (pPrev->n!=n || memcmp(pPrev->p, z, n)) ){
214649 fts5BufferSet(&rc, pPrev, n, (const u8*)z);
214660 # define fts5TestDlidxReverse(x,y,z)
214661 # define fts5TestTerm(u,v,w,x,y,z)
214936 char *z = (char*)fts5MultiIterTerm(pIter, &n);
214939 fts5TestTerm(p, &term, z, n, cksum2, &cksum3);
214943 cksum2 ^= sqlite3Fts5IndexEntryCksum(iRowid, 0, 0, -1, z, n);
214951 cksum2 ^= sqlite3Fts5IndexEntryCksum(iRowid, iCol, iTokOff, -1, z, n);
215753 # define fts5CheckTransactionState(x,y,z)
216430 const char *z = zQuery; /* Special query text */
216433 while( z[0]==' ' ) z++;
216434 for(n=0; z[n] && z[n]!=' '; n++);
216439 if( 0==sqlite3_strnicmp("reads", z, n) ){
216442 else if( 0==sqlite3_strnicmp("id", z, n) ){
216447 pTab->p.base.zErrMsg = sqlite3_mprintf("unknown special query: %.*s", n, z);
216529 const char *z = (const char*)sqlite3_value_text(pRank);
216533 if( z==0 ){
216536 rc = sqlite3Fts5ConfigParseRank(z, &zRank, &zRankArgs);
216544 "parse error in rank function: %s", z
216968 const char *z = (const char*)sqlite3_value_text(apVal[2+pConfig->nCol]);
216970 && 0==sqlite3_stricmp("delete", z)
216974 rc = fts5SpecialInsert(pTab, z, apVal[2 + pConfig->nCol + 1]);
217199 int n; const char *z;
217200 rc = fts5ApiColumnText((Fts5Context*)pCsr, i, &z, &n);
217203 pConfig, pCsr->pExpr, aPopulator, i, z, n
217386 const char *z; int n;
217389 rc = fts5ApiColumnText(pCtx, i, &z, &n);
217392 pConfig, FTS5_TOKENIZE_AUX, z, n, p, fts5ColumnSizeCb
219353 const char *z,
219360 sqlite3_bind_text(pReplace, 1, z, -1, SQLITE_STATIC);
219630 const char *z, /* Characters to treat as exceptions */
219634 int n = (int)strlen(z);
219642 const unsigned char *zCsr = (const unsigned char*)z;
219643 const unsigned char *zTerm = (const unsigned char*)&z[n];
219713 const char *z = zCat;
219715 while( *z ){
219716 while( *z==' ' || *z=='\t' ) z++;
219717 if( *z && sqlite3Fts5UnicodeCatParse(z, p->aCategory) ){
219720 while( *z!=' ' && *z!='\t' && *z!='\0' ) z++;
222468 const char *z = pCsr->pFts5->pConfig->azCol[pCsr->iCol];
222469 sqlite3_result_text(pCtx, z, -1, SQLITE_STATIC);
222497 const char *z = pCsr->pFts5->pConfig->azCol[ii];
222498 sqlite3_result_text(pCtx, z, -1, SQLITE_STATIC);
