Lines Matching defs:ENC
18531 u8 enc; /* Text encoding used by this database */
18703 u8 enc; /* Text encoding */
18834 #define SCHEMA_ENC(db) ((db)->aDb[0].pSchema->enc)
18835 #define ENC(db) ((db)->enc)
18915 #define DBFLAG_EncodingFixed 0x0040 /* No longer possible to change enc. */
19327 u8 enc; /* Text encoding handled by xCmp() */
19690 u8 enc; /* Text encoding - one of the SQLITE_UTF* values */
22411 SQLITE_PRIVATE CollSeq *sqlite3FindCollSeq(sqlite3*,u8 enc, const char*,int);
24513 u8 enc; /* SQLITE_UTF8, SQLITE_UTF16BE, SQLITE_UTF16LE */
24672 u8 enc; /* Encoding to use for results */
36014 assert( pMem->enc!=desiredEnc );
36015 assert( pMem->enc!=0 );
36032 if( pMem->enc!=SQLITE_UTF8 && desiredEnc!=SQLITE_UTF8 ){
36048 pMem->enc = desiredEnc;
36084 if( pMem->enc==SQLITE_UTF8 ){
36103 if( pMem->enc==SQLITE_UTF16LE ){
36170 pMem->enc = desiredEnc;
36194 ** byte-swapping, it just sets Mem.enc appropriately.
36223 pMem->enc = bom;
36291 SQLITE_PRIVATE char *sqlite3Utf16to8(sqlite3 *db, const void *z, int nByte, u8 enc){
36295 sqlite3VdbeMemSetStr(&m, z, nByte, enc, SQLITE_STATIC);
37519 ** given by enc.
37521 SQLITE_PRIVATE int sqlite3Atoi64(const char *zNum, i64 *pNum, int length, u8 enc){
37531 assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
37532 if( enc==SQLITE_UTF8 ){
37538 for(i=3-enc; i<length && zNum[i]==0; i+=2){}
37541 zNum += (enc&1);
85631 assert( p->enc==SQLITE_UTF8 || p->szMalloc >= ((p->n+1)&~1)+2 );
85632 assert( p->enc!=SQLITE_UTF8 || p->szMalloc >= p->n+1 );
85635 assert( p->enc==SQLITE_UTF8 || p->z[(p->n+1)&~1]==0 );
85636 assert( p->enc==SQLITE_UTF8 || p->z[((p->n+1)&~1)+1]==0 );
85647 if( p->enc!=SQLITE_UTF8 ){
85649 if( p->enc==SQLITE_UTF16BE ) z++;
85681 pMem->enc = desiredEnc;
85684 if( pMem->enc==desiredEnc ){
85697 assert(rc==SQLITE_OK || pMem->enc!=desiredEnc);
85698 assert(rc==SQLITE_NOMEM || pMem->enc==desiredEnc);
85801 if( pMem->enc!=SQLITE_UTF8 ) return 0;
85931 SQLITE_PRIVATE int sqlite3VdbeMemStringify(Mem *pMem, u8 enc, u8 bForce){
85944 pMem->enc = 0;
85951 pMem->enc = SQLITE_UTF8;
85954 sqlite3VdbeChangeEncoding(pMem, enc);
85982 ctx.enc = ENC(t.db);
86011 ctx.enc = ENC(pAccum->db);
86098 sqlite3Atoi64(pMem->z, &value, pMem->n, pMem->enc);
86143 if( pMem->enc==SQLITE_UTF8 ){
86159 if( pMem->enc==SQLITE_UTF16LE ){
86201 }else if( pMem->enc==SQLITE_UTF8
86365 if( ((rc&2)==0 && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)<2)
86475 pMem->enc = SQLITE_UTF8;
86489 pMem->enc = SQLITE_UTF8;
86726 ** The "enc" parameter is the text encoding for the string, or zero
86737 u8 enc, /* Encoding of z. 0 for BLOBs */
86747 assert( enc!=0 || n>=0 );
86761 assert( enc!=0 );
86762 if( enc==SQLITE_UTF8 ){
86768 }else if( enc==0 ){
86770 enc = SQLITE_UTF8;
86793 nAlloc += (enc==SQLITE_UTF8?1:2);
86817 pMem->enc = enc;
86820 if( enc>SQLITE_UTF8 && sqlite3VdbeMemHandleBom(pMem) ){
86831 ** enc is always SQLITE_UTF8
86903 pMem->enc = SQLITE_UTF8;
86979 ** Convert it into a string with encoding enc and return a pointer
86982 static SQLITE_NOINLINE const void *valueToText(sqlite3_value* pVal, u8 enc){
86985 assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) );
86991 if( pVal->enc != (enc & ~SQLITE_UTF16_ALIGNED) ){
86992 sqlite3VdbeChangeEncoding(pVal, enc & ~SQLITE_UTF16_ALIGNED);
86994 if( (enc & SQLITE_UTF16_ALIGNED)!=0 && 1==(1&SQLITE_PTR_TO_INT(pVal->z)) ){
87002 sqlite3VdbeMemStringify(pVal, enc, 0);
87005 assert(pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) || pVal->db==0
87007 if( pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) ){
87021 ** (2006-02-16:) The enc value can be or-ed with SQLITE_UTF16_ALIGNED.
87025 SQLITE_PRIVATE const void *sqlite3ValueText(sqlite3_value* pVal, u8 enc){
87028 assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) );
87030 if( (pVal->flags&(MEM_Str|MEM_Term))==(MEM_Str|MEM_Term) && pVal->enc==enc ){
87037 return valueToText(pVal, enc);
87109 assert( pRec->pKeyInfo->enc==ENC(db) );
87148 ** enc.
87158 u8 enc, /* Encoding to use */
87178 pFunc = sqlite3FindFunction(db, p->u.zToken, nVal, enc, 0);
87211 ctx.enc = ENC(db);
87219 rc = sqlite3VdbeChangeEncoding(pVal, enc);
87258 u8 enc, /* Encoding to use */
87284 rc = valueFromExpr(db, pExpr->pLeft, enc, aff, ppVal, pCtx);
87294 sqlite3VdbeMemCast(*ppVal, aff, enc);
87295 enc);
87352 if( enc!=SQLITE_UTF8 ){
87353 rc = sqlite3VdbeChangeEncoding(pVal, enc);
87357 if( SQLITE_OK==valueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal,pCtx)
87373 sqlite3ValueApplyAffinity(pVal, affinity, enc);
87397 rc = valueFromFunction(db, pExpr, enc, affinity, &pVal, pCtx);
87406 sqlite3ValueApplyAffinity(pVal, affinity, enc);
87441 u8 enc, /* Encoding to use */
87445 return pExpr ? valueFromExpr(db, pExpr, enc, affinity, ppVal, 0) : 0;
87495 sqlite3ValueApplyAffinity(pVal, affinity, ENC(db));
87500 rc = valueFromExpr(db, pExpr, ENC(db), affinity, &pVal, pAlloc);
87645 pMem->enc = ENC(db);
87676 u8 enc, /* Encoding to use */
87679 if( v ) sqlite3VdbeMemSetStr((Mem *)v, z, n, enc, xDel);
87693 ** sqlite3_value object assuming that it uses the encoding "enc".
87696 static SQLITE_NOINLINE int valueBytes(sqlite3_value *pVal, u8 enc){
87697 return valueToText(pVal, enc)!=0 ? pVal->n : 0;
87699 SQLITE_PRIVATE int sqlite3ValueBytes(sqlite3_value *pVal, u8 enc){
87702 if( (p->flags & MEM_Str)!=0 && pVal->enc==enc ){
87705 if( (p->flags & MEM_Str)!=0 && enc!=SQLITE_UTF8 && pVal->enc!=SQLITE_UTF8 ){
87716 return valueBytes(pVal, enc);
89657 assert( pColl->enc<4 );
89659 encnames[pColl->enc]);
91984 pMem->enc = pKeyInfo->enc;
92035 mem1.enc = pKeyInfo->enc;
92184 v1 = sqlite3ValueText((sqlite3_value*)&c1, pColl->enc);
92185 v2 = sqlite3ValueText((sqlite3_value*)&c2, pColl->enc);
92202 if( pMem1->enc==pColl->enc ){
92369 assert( pMem1->enc==pMem2->enc || pMem1->db->mallocFailed );
92370 assert( pMem1->enc==SQLITE_UTF8 ||
92371 pMem1->enc==SQLITE_UTF16LE || pMem1->enc==SQLITE_UTF16BE );
92576 mem1.enc = pKeyInfo->enc;
93177 mem.enc = p->pKeyInfo->enc;
93484 preupdate.pKeyinfo->enc = ENC(db);
93858 return pVal->enc;
93919 u8 enc, /* Encoding of z. 0 for BLOBs */
93924 if( enc==SQLITE_UTF8 ){
93926 }else if( enc==SQLITE_UTF8_ZT ){
93938 rc = sqlite3VdbeMemSetStr(pOut, z, n, enc, xDel);
93951 sqlite3VdbeChangeEncoding(pOut, pCtx->enc);
94122 unsigned char enc
94132 if( enc!=SQLITE_UTF8 && enc!=SQLITE_UTF8_ZT ){
94133 if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE;
94139 setResultStrOrError(pCtx, z, (int)n, enc, xDel);
94185 sqlite3VdbeChangeEncoding(pOut, pCtx->enc);
94599 pOut->enc = ENC(pOut->db);
94832 /* .enc = */ (u8)0,
95256 if( encoding==0 ) pVar->enc = ENC(p->db);
95259 rc = sqlite3VdbeChangeEncoding(pVar, ENC(p->db));
95368 unsigned char enc
95371 if( enc!=SQLITE_UTF8 && enc!=SQLITE_UTF8_ZT ){
95372 if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE;
95375 return bindText(pStmt, i, zData, nData, xDel, enc);
95412 pValue->enc);
95812 rc = sqlite3ValueFromExpr(db, pDflt, ENC(db), pCol->affinity, &pVal);
96301 u8 enc = ENC(db);
96302 if( enc!=SQLITE_UTF8 ){
96305 sqlite3VdbeMemSetStr(&utf8, pVar->z, pVar->n, enc, SQLITE_STATIC);
96327 if( enc!=SQLITE_UTF8 ) sqlite3VdbeMemRelease(&utf8);
96782 return 0==sqlite3Atoi64(pRec->z, piValue, pRec->n, pRec->enc);
96846 u8 enc /* Use this text encoding */
96869 sqlite3VdbeMemStringify(pRec, enc, 1);
96902 u8 enc
96904 applyAffinity((Mem *)pVal, affinity, enc);
96924 if( (rc&2)==0 && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)<=1 ){
96930 }else if( (rc&2)==0 && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)==0 ){
97016 sqlite3_str_appendf(pStr, "]%s", encnames[pMem->enc]);
97176 int encoding = pDest->enc;
97305 u8 encoding = ENC(db); /* The database encoding */
97910 pOut->enc = encoding;
98011 pOut->enc = encoding;
98294 pOut->enc = encoding;
99651 pDest->enc = encoding;
99666 pDest->enc = encoding;
100881 assert( pKeyInfo->enc==ENC(db) );
101041 assert( pKeyInfo->enc==ENC(db) );
101088 assert( pCx->pKeyInfo->enc==ENC(db) );
104315 pCtx->enc = encoding;
104587 pOut->enc = SQLITE_UTF8;
105022 sContext.enc = encoding;
105112 testcase( pName->enc==SQLITE_UTF8 );
105113 testcase( pName->enc==SQLITE_UTF16BE );
105114 testcase( pName->enc==SQLITE_UTF16LE );
105311 pCtx->enc = encoding;
105339 || pOut->enc==encoding
111443 u8 enc = ENC(pParse->db); /* The database encoding */
111453 pDef = sqlite3FindFunction(pParse->db, zId, n, enc, 0);
111455 pDef = sqlite3FindFunction(pParse->db, zId, -2, enc, 0);
112908 pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0);
112925 pColl = sqlite3GetCollSeq(pParse, ENC(db), 0, p->u.zToken);
115147 pDef = sqlite3FindFunction(db, pExpr->u.zToken, n, ENC(db), 0);
117359 pDef = sqlite3FindFunction(db, pExpr->u.zToken, n, ENC(db), 0);
117979 u8 enc = ENC(db); /* The text encoding used by this database */
118001 pDef = sqlite3FindFunction(db, zId, nFarg, enc, 0);
118004 pDef = sqlite3FindFunction(db, "unknown", nFarg, enc, 0);
119425 pDef = sqlite3FindFunction(db, z, pExpr->x.pList->nExpr, ENC(db), 0);
120122 u8 enc = ENC(pParse->db);
120132 pExpr->u.zToken, nArg, enc, 0);
125623 }else if( pNew->pSchema->file_format && pNew->pSchema->enc!=ENC(db) ){
127666 sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_TEXT_ENCODING, ENC(db));
131915 if( zDb==0 && sqlite3FindCollSeq(db, ENC(db), z, 0)!=0 ){
132147 ** in the encoding enc of name zName, length nName.
132149 static void callCollNeeded(sqlite3 *db, int enc, const char *zName){
132154 db->xCollNeeded(db->pCollNeededArg, db, enc, zExternal);
132164 db->xCollNeeded16(db->pCollNeededArg, db, (int)ENC(db), zExternal);
132209 CollSeq *p = sqlite3GetCollSeq(pParse, ENC(db), pColl, zName);
132247 pColl[0].enc = SQLITE_UTF8;
132249 pColl[1].enc = SQLITE_UTF16LE;
132251 pColl[2].enc = SQLITE_UTF16BE;
132273 ** for the encoding 'enc' from the database 'db'.
132287 u8 enc, /* Desired text encoding */
132293 assert( enc>=SQLITE_UTF8 && enc<=SQLITE_UTF16BE );
132296 if( pColl ) pColl += enc-1;
132307 SQLITE_PRIVATE void sqlite3SetTextEncoding(sqlite3 *db, u8 enc){
132308 assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
132309 db->enc = enc;
132313 db->pDfltColl = sqlite3FindCollSeq(db, enc, sqlite3StrBINARY, 0);
132333 u8 enc, /* The desired encoding for the collating sequence */
132342 p = sqlite3FindCollSeq(db, enc, zName, 0);
132348 callCollNeeded(db, enc, zName);
132349 p = sqlite3FindCollSeq(db, enc, zName, 0);
132384 u8 enc = ENC(db);
132388 pColl = sqlite3FindCollSeq(db, enc, zName, initbusy);
132390 pColl = sqlite3GetCollSeq(pParse, enc, pColl, zName);
132399 ** that uses encoding enc. The value returned indicates how well the
132428 u8 enc /* Desired text encoding */
132454 if( enc==(p->funcFlags & SQLITE_FUNC_ENCMASK) ){
132456 }else if( (enc & p->funcFlags & 2)!=0 ){
132533 u8 enc, /* Preferred text encoding */
132550 int score = matchQuality(p, nArg, enc);
132575 int score = matchQuality(p, nArg, enc);
132594 pBest->funcFlags = enc;
132670 p->enc = SQLITE_UTF8;
133879 i64 m = sqlite3_context_db_handle(context)->enc<=SQLITE_UTF8 ? 1 : 2;
144012 /* 18 */ "enc",
146492 sqlite3ValueFromExpr(db, sqlite3ColumnExpr(pTab,pCol), ENC(db),
146803 u8 enc;
146818 assert( encnames[SQLITE_UTF8].enc==SQLITE_UTF8 );
146819 assert( encnames[SQLITE_UTF16LE].enc==SQLITE_UTF16LE );
146820 enc==SQLITE_UTF16BE );
146821 returnSingleText(v, encnames[ENC(pParse->db)].zName);
146823 /* Only change the value of sqlite.enc if the database handle is not
146824 ** initialized. If the main database exists, the new sqlite.enc value
146831 u8 enc = pEnc->enc ? pEnc->enc : SQLITE_UTF16NATIVE;
146832 SCHEMA_ENC(db) = enc;
146833 sqlite3SetTextEncoding(db, enc);
147959 ** main database, set sqlite3.enc to the encoding of the main database.
147961 ** as sqlite3.enc.
147967 /* If opening the main database, set ENC(db). */
147975 /* If opening an attached database, the encoding much match ENC(db) */
147976 if( (meta[BTREE_TEXT_ENCODING-1] & 3)!=ENC(db) ){
147984 pDb->pSchema->enc = ENC(db);
148108 ENC(db) = SCHEMA_ENC(db);
150300 p->enc = ENC(db);
159559 u8 enc = ENC(sqlite3VdbeDb(v));
159564 sqlite3ColumnExpr(pTab,pCol), enc,
166859 || ENC(db)==SQLITE_UTF16LE
166881 *pisComplete = c==wc[0] && z[cnt+1]==0 && ENC(db)!=SQLITE_UTF16LE;
173179 pH->pParse->db, pTerm->pExpr->pRight, ENC(pH->pParse->db),
178914 sqlite3ValueFromExpr(db, pExpr, db->enc, SQLITE_AFF_NUMERIC, &pVal);
189037 int enc,
189063 extraFlags = enc & (SQLITE_DETERMINISTIC|SQLITE_DIRECTONLY|
189066 enc &= (SQLITE_FUNC_ENCMASK|SQLITE_ANY);
189082 switch( enc ){
189084 enc = SQLITE_UTF16NATIVE;
189099 enc = SQLITE_UTF16BE;
189107 enc = SQLITE_UTF8;
189111 enc = SQLITE_UTF8;
189119 p = sqlite3FindFunction(db, zFunctionName, nArg, (u8)enc, 0);
189120 if( p && (p->funcFlags & SQLITE_FUNC_ENCMASK)==(u32)enc && p->nArg==nArg ){
189135 p = sqlite3FindFunction(db, zFunctionName, nArg, (u8)enc, 1);
189172 int enc,
189201 rc = sqlite3CreateFunc(db, zFunc, nArg, enc, p,
189223 int enc,
189229 return createFunctionApi(db, zFunc, nArg, enc, p, xSFunc, xStep,
189236 int enc,
189243 return createFunctionApi(db, zFunc, nArg, enc, p, xSFunc, xStep,
189250 int enc,
189258 return createFunctionApi(db, zFunc, nArg, enc, p, 0, xStep,
189952 ** and the encoding is enc.
189957 u8 enc,
189971 enc2 = enc;
190000 if( (pColl->enc & ~SQLITE_UTF16_ALIGNED)==enc2 ){
190005 if( p->enc==pColl->enc ){
190020 pColl->enc = (u8)(enc2 | (enc & SQLITE_UTF16_ALIGNED));
190833 SCHEMA_ENC(*ppDb) = ENC(*ppDb) = SQLITE_UTF16NATIVE;
190850 int enc,
190854 return sqlite3_create_collation_v2(db, zName, enc, pCtx, xCompare, 0);
190863 int enc,
190875 rc = createCollation(db, zName, (u8)enc, pCtx, xCompare, xDel);
190888 int enc,
190902 rc = createCollation(db, zName8, (u8)enc, pCtx, xCompare, 0);
224218 int enc;
224220 enc = SQLITE_UTF8|SQLITE_DETERMINISTIC|SQLITE_INNOCUOUS;
224222 enc = SQLITE_UTF8|SQLITE_DIRECTONLY;
224225 enc, 0,
224960 unsigned int enc; /* Optimal text encoding */
224986 db, p->zName, p->nArg, p->enc,
236854 u8 enc /* String encoding (0 for blobs) */
236863 sqlite3ValueSetStr(pVal, nData, (char*)aCopy, enc, sqlite3_free);
236932 u8 enc = (eType==SQLITE_TEXT ? SQLITE_UTF8 : 0);
236933 rc = sessionValueSetStr(apOut[i],&pIn->aData[pIn->iNext],nByte,enc);
Indexes created Mon May 04 00:23:20 UTC 2026