Lines Matching defs:enc
16822 u8 enc; /* Text encoding used by this database */
17028 u8 enc; /* Text encoding */
17161 #define SCHEMA_ENC(db) ((db)->aDb[0].pSchema->enc)
17162 #define ENC(db) ((db)->enc)
17237 #define DBFLAG_EncodingFixed 0x0040 /* No longer possible to change enc. */
17633 u8 enc; /* Text encoding handled by xCmp() */
17973 u8 enc; /* Text encoding - one of the SQLITE_UTF* values */
20492 SQLITE_PRIVATE CollSeq *sqlite3FindCollSeq(sqlite3*,u8 enc, const char*,int);
22627 u8 enc; /* SQLITE_UTF8, SQLITE_UTF16BE, SQLITE_UTF16LE */
22785 u8 enc; /* Encoding to use for results */
33253 assert( pMem->enc!=desiredEnc );
33254 assert( pMem->enc!=0 );
33271 if( pMem->enc!=SQLITE_UTF8 && desiredEnc!=SQLITE_UTF8 ){
33287 pMem->enc = desiredEnc;
33323 if( pMem->enc==SQLITE_UTF8 ){
33342 if( pMem->enc==SQLITE_UTF16LE ){
33409 pMem->enc = desiredEnc;
33433 ** byte-swapping, it just sets Mem.enc appropriately.
33462 pMem->enc = bom;
33530 SQLITE_PRIVATE char *sqlite3Utf16to8(sqlite3 *db, const void *z, int nByte, u8 enc){
33534 sqlite3VdbeMemSetStr(&m, z, nByte, enc, SQLITE_STATIC);
34012 ** uses the encoding enc. The string is not necessarily zero-terminated.
34039 SQLITE_PRIVATE int sqlite3AtoF(const char *z, double *pResult, int length, u8 enc){
34054 assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
34058 if( enc==SQLITE_UTF8 ){
34066 testcase( enc==SQLITE_UTF16LE );
34067 testcase( enc==SQLITE_UTF16BE );
34068 for(i=3-enc; i<length && z[i]==0; i+=2){}
34071 z += (enc&1);
34226 return !sqlite3Atoi64(z, pResult, length, enc);
34302 ** given by enc.
34304 SQLITE_PRIVATE int sqlite3Atoi64(const char *zNum, i64 *pNum, int length, u8 enc){
34314 assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
34315 if( enc==SQLITE_UTF8 ){
34321 for(i=3-enc; i<length && zNum[i]==0; i+=2){}
34324 zNum += (enc&1);
80710 assert( p->enc==SQLITE_UTF8 || p->szMalloc >= ((p->n+1)&~1)+2 );
80711 assert( p->enc!=SQLITE_UTF8 || p->szMalloc >= p->n+1 );
80714 assert( p->enc==SQLITE_UTF8 || p->z[(p->n+1)&~1]==0 );
80715 assert( p->enc==SQLITE_UTF8 || p->z[((p->n+1)&~1)+1]==0 );
80722 if( p->enc!=SQLITE_UTF8 ){
80724 if( p->enc==SQLITE_UTF16BE ) z++;
80756 pMem->enc = desiredEnc;
80759 if( pMem->enc==desiredEnc ){
80772 assert(rc==SQLITE_OK || pMem->enc!=desiredEnc);
80773 assert(rc==SQLITE_NOMEM || pMem->enc==desiredEnc);
80968 SQLITE_PRIVATE int sqlite3VdbeMemStringify(Mem *pMem, u8 enc, u8 bForce){
80981 pMem->enc = 0;
80988 pMem->enc = SQLITE_UTF8;
80991 sqlite3VdbeChangeEncoding(pMem, enc);
81019 ctx.enc = ENC(t.db);
81048 ctx.enc = ENC(pAccum->db);
81165 sqlite3Atoi64(pMem->z, &value, pMem->n, pMem->enc);
81195 sqlite3AtoF(pMem->z, &val, pMem->n, pMem->enc);
81329 rc = sqlite3AtoF(pMem->z, &pMem->u.r, pMem->n, pMem->enc);
81330 if( ((rc==0 || rc==1) && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)<=1)
81437 pMem->enc = SQLITE_UTF8;
81451 pMem->enc = SQLITE_UTF8;
81678 ** The "enc" parameter is the text encoding for the string, or zero
81689 u8 enc, /* Encoding of z. 0 for BLOBs */
81699 assert( enc!=0 || n>=0 );
81713 assert( enc!=0 );
81714 if( enc==SQLITE_UTF8 ){
81720 }else if( enc==0 ){
81722 enc = SQLITE_UTF8;
81745 nAlloc += (enc==SQLITE_UTF8?1:2);
81768 pMem->enc = enc;
81771 if( enc>SQLITE_UTF8 && sqlite3VdbeMemHandleBom(pMem) ){
81847 ** Convert it into a string with encoding enc and return a pointer
81850 static SQLITE_NOINLINE const void *valueToText(sqlite3_value* pVal, u8 enc){
81853 assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) );
81859 if( pVal->enc != (enc & ~SQLITE_UTF16_ALIGNED) ){
81860 sqlite3VdbeChangeEncoding(pVal, enc & ~SQLITE_UTF16_ALIGNED);
81862 if( (enc & SQLITE_UTF16_ALIGNED)!=0 && 1==(1&SQLITE_PTR_TO_INT(pVal->z)) ){
81870 sqlite3VdbeMemStringify(pVal, enc, 0);
81873 assert(pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) || pVal->db==0
81875 if( pVal->enc==(enc & ~SQLITE_UTF16_ALIGNED) ){
81889 ** (2006-02-16:) The enc value can be or-ed with SQLITE_UTF16_ALIGNED.
81893 SQLITE_PRIVATE const void *sqlite3ValueText(sqlite3_value* pVal, u8 enc){
81896 assert( (enc&3)==(enc&~SQLITE_UTF16_ALIGNED) );
81898 if( (pVal->flags&(MEM_Str|MEM_Term))==(MEM_Str|MEM_Term) && pVal->enc==enc ){
81905 return valueToText(pVal, enc);
81959 assert( pRec->pKeyInfo->enc==ENC(db) );
81997 ** enc.
82007 u8 enc, /* Encoding to use */
82027 pFunc = sqlite3FindFunction(db, p->u.zToken, nVal, enc, 0);
82042 rc = sqlite3ValueFromExpr(db, pList->a[i].pExpr, enc, aff, &apVal[i]);
82058 ctx.enc = ENC(db);
82066 rc = sqlite3VdbeChangeEncoding(pVal, enc);
82105 u8 enc, /* Encoding to use */
82131 rc = valueFromExpr(db, pExpr->pLeft, enc, aff, ppVal, pCtx);
82134 sqlite3VdbeMemCast(*ppVal, aff, enc);
82135 sqlite3ValueApplyAffinity(*ppVal, affinity, enc);
82172 if( enc!=SQLITE_UTF8 ){
82173 rc = sqlite3VdbeChangeEncoding(pVal, enc);
82177 if( SQLITE_OK==valueFromExpr(db,pExpr->pLeft,enc,affinity,&pVal,pCtx)
82193 sqlite3ValueApplyAffinity(pVal, affinity, enc);
82217 rc = valueFromFunction(db, pExpr, enc, affinity, &pVal, pCtx);
82260 u8 enc, /* Encoding to use */
82264 return pExpr ? valueFromExpr(db, pExpr, enc, affinity, ppVal, 0) : 0;
82459 pMem->enc = ENC(db);
82490 u8 enc, /* Encoding to use */
82493 if( v ) sqlite3VdbeMemSetStr((Mem *)v, z, n, enc, xDel);
82507 ** sqlite3_value object assuming that it uses the encoding "enc".
82510 static SQLITE_NOINLINE int valueBytes(sqlite3_value *pVal, u8 enc){
82511 return valueToText(pVal, enc)!=0 ? pVal->n : 0;
82513 SQLITE_PRIVATE int sqlite3ValueBytes(sqlite3_value *pVal, u8 enc){
82516 if( (p->flags & MEM_Str)!=0 && pVal->enc==enc ){
82519 if( (p->flags & MEM_Str)!=0 && enc!=SQLITE_UTF8 && pVal->enc!=SQLITE_UTF8 ){
82530 return valueBytes(pVal, enc);
84315 assert( pColl->enc<4 );
84317 encnames[pColl->enc]);
86618 pMem->enc = pKeyInfo->enc;
86667 mem1.enc = pKeyInfo->enc;
86799 if( pMem1->enc==pColl->enc ){
86812 v1 = sqlite3ValueText((sqlite3_value*)&c1, pColl->enc);
86813 v2 = sqlite3ValueText((sqlite3_value*)&c2, pColl->enc);
86979 assert( pMem1->enc==pMem2->enc || pMem1->db->mallocFailed );
86980 assert( pMem1->enc==SQLITE_UTF8 ||
86981 pMem1->enc==SQLITE_UTF16LE || pMem1->enc==SQLITE_UTF16BE );
87182 mem1.enc = pKeyInfo->enc;
87837 preupdate.keyinfo.enc = ENC(db);
88184 return pVal->enc;
88245 u8 enc, /* Encoding of z. 0 for BLOBs */
88249 int rc = sqlite3VdbeMemSetStr(pOut, z, n, enc, xDel);
88261 sqlite3VdbeChangeEncoding(pOut, pCtx->enc);
88366 unsigned char enc
88370 if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE;
88374 setResultStrOrError(pCtx, z, (int)n, enc, xDel);
88410 sqlite3VdbeChangeEncoding(pOut, pCtx->enc);
88818 pOut->enc = ENC(pOut->db);
89043 /* .enc = */ (u8)0,
89504 unsigned char enc
89507 if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE;
89508 return bindText(pStmt, i, zData, nData, xDel, enc);
89545 pValue->enc);
90213 u8 enc = ENC(db);
90214 if( enc!=SQLITE_UTF8 ){
90217 sqlite3VdbeMemSetStr(&utf8, pVar->z, pVar->n, enc, SQLITE_STATIC);
90239 if( enc!=SQLITE_UTF8 ) sqlite3VdbeMemRelease(&utf8);
90593 return 0==sqlite3Atoi64(pRec->z, piValue, pRec->n, pRec->enc);
90613 u8 enc = pRec->enc;
90616 rc = sqlite3AtoF(pRec->z, &rValue, pRec->n, enc);
90654 u8 enc /* Use this text encoding */
90677 sqlite3VdbeMemStringify(pRec, enc, 1);
90707 u8 enc
90709 applyAffinity((Mem *)pVal, affinity, enc);
90727 rc = sqlite3AtoF(pMem->z, &pMem->u.r, pMem->n, pMem->enc);
90729 if( rc==0 && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)<=1 ){
90735 }else if( rc==1 && sqlite3Atoi64(pMem->z, &ix, pMem->n, pMem->enc)==0 ){
90820 sqlite3_str_appendf(pStr, "]%s", encnames[pMem->enc]);
91636 pOut->enc = encoding;
91737 pOut->enc = encoding;
92056 pOut->enc = encoding;
93400 pDest->enc = encoding;
93414 pDest->enc = encoding;
94592 assert( pKeyInfo->enc==ENC(db) );
94752 assert( pKeyInfo->enc==ENC(db) );
94794 assert( pCx->pKeyInfo->enc==ENC(db) );
97868 pCtx->enc = encoding;
98138 pOut->enc = SQLITE_UTF8;
98518 sContext.enc = encoding;
98605 testcase( pName->enc==SQLITE_UTF8 );
98606 testcase( pName->enc==SQLITE_UTF16BE );
98607 testcase( pName->enc==SQLITE_UTF16LE );
98803 pCtx->enc = encoding;
98831 || pOut->enc==encoding
104671 u8 enc = ENC(pParse->db); /* The database encoding */
104678 pDef = sqlite3FindFunction(pParse->db, zId, n, enc, 0);
104680 pDef = sqlite3FindFunction(pParse->db, zId, -2, enc, 0);
110269 u8 enc = ENC(db); /* The text encoding used by this database */
110289 pDef = sqlite3FindFunction(db, zId, nFarg, enc, 0);
110292 pDef = sqlite3FindFunction(db, "unknown", nFarg, enc, 0);
112167 u8 enc = ENC(pParse->db);
112177 pExpr->x.pList ? pExpr->x.pList->nExpr : 0, enc, 0);
116726 }else if( pNew->pSchema->file_format && pNew->pSchema->enc!=ENC(db) ){
123176 ** in the encoding enc of name zName, length nName.
123178 static void callCollNeeded(sqlite3 *db, int enc, const char *zName){
123183 db->xCollNeeded(db->pCollNeededArg, db, enc, zExternal);
123276 pColl[0].enc = SQLITE_UTF8;
123278 pColl[1].enc = SQLITE_UTF16LE;
123280 pColl[2].enc = SQLITE_UTF16BE;
123302 ** for the encoding 'enc' from the database 'db'.
123316 u8 enc, /* Desired text encoding */
123322 assert( enc>=SQLITE_UTF8 && enc<=SQLITE_UTF16BE );
123325 if( pColl ) pColl += enc-1;
123336 SQLITE_PRIVATE void sqlite3SetTextEncoding(sqlite3 *db, u8 enc){
123337 assert( enc==SQLITE_UTF8 || enc==SQLITE_UTF16LE || enc==SQLITE_UTF16BE );
123338 db->enc = enc;
123342 db->pDfltColl = sqlite3FindCollSeq(db, enc, sqlite3StrBINARY, 0);
123361 u8 enc, /* The desired encoding for the collating sequence */
123370 p = sqlite3FindCollSeq(db, enc, zName, 0);
123376 callCollNeeded(db, enc, zName);
123377 p = sqlite3FindCollSeq(db, enc, zName, 0);
123412 u8 enc = ENC(db);
123416 pColl = sqlite3FindCollSeq(db, enc, zName, initbusy);
123418 pColl = sqlite3GetCollSeq(pParse, enc, pColl, zName);
123427 ** that uses encoding enc. The value returned indicates how well the
123456 u8 enc /* Desired text encoding */
123476 if( enc==(p->funcFlags & SQLITE_FUNC_ENCMASK) ){
123478 }else if( (enc & p->funcFlags & 2)!=0 ){
123555 u8 enc, /* Preferred text encoding */
123572 int score = matchQuality(p, nArg, enc);
123597 int score = matchQuality(p, nArg, enc);
123616 pBest->funcFlags = enc;
123691 p->enc = SQLITE_UTF8;
133667 /* 30 */ "enc",
136332 u8 enc;
136347 assert( encnames[SQLITE_UTF8].enc==SQLITE_UTF8 );
136348 assert( encnames[SQLITE_UTF16LE].enc==SQLITE_UTF16LE );
136349 assert( encnames[SQLITE_UTF16BE].enc==SQLITE_UTF16BE );
136352 /* Only change the value of sqlite.enc if the database handle is not
136353 ** initialized. If the main database exists, the new sqlite.enc value
136360 u8 enc = pEnc->enc ? pEnc->enc : SQLITE_UTF16NATIVE;
136361 SCHEMA_ENC(db) = enc;
136362 sqlite3SetTextEncoding(db, enc);
137438 ** main database, set sqlite3.enc to the encoding of the main database.
137440 ** as sqlite3.enc.
137463 pDb->pSchema->enc = ENC(db);
139731 p->enc = ENC(db);
147908 u8 enc = ENC(sqlite3VdbeDb(v));
147913 sqlite3ColumnExpr(pTab,pCol), enc,
165560 sqlite3ValueFromExpr(db, pExpr, db->enc, SQLITE_AFF_NUMERIC, &pVal);
175247 int enc,
175273 extraFlags = enc & (SQLITE_DETERMINISTIC|SQLITE_DIRECTONLY|
175275 enc &= (SQLITE_FUNC_ENCMASK|SQLITE_ANY);
175291 switch( enc ){
175293 enc = SQLITE_UTF16NATIVE;
175308 enc = SQLITE_UTF16BE;
175316 enc = SQLITE_UTF8;
175320 enc = SQLITE_UTF8;
175328 p = sqlite3FindFunction(db, zFunctionName, nArg, (u8)enc, 0);
175329 if( p && (p->funcFlags & SQLITE_FUNC_ENCMASK)==(u32)enc && p->nArg==nArg ){
175344 p = sqlite3FindFunction(db, zFunctionName, nArg, (u8)enc, 1);
175381 int enc,
175410 rc = sqlite3CreateFunc(db, zFunc, nArg, enc, p,
175432 int enc,
175438 return createFunctionApi(db, zFunc, nArg, enc, p, xSFunc, xStep,
175445 int enc,
175452 return createFunctionApi(db, zFunc, nArg, enc, p, xSFunc, xStep,
175459 int enc,
175467 return createFunctionApi(db, zFunc, nArg, enc, p, 0, xStep,
176123 ** and the encoding is enc.
176128 u8 enc,
176142 enc2 = enc;
176171 if( (pColl->enc & ~SQLITE_UTF16_ALIGNED)==enc2 ){
176176 if( p->enc==pColl->enc ){
176191 pColl->enc = (u8)(enc2 | (enc & SQLITE_UTF16_ALIGNED));
177052 int enc,
177056 return sqlite3_create_collation_v2(db, zName, enc, pCtx, xCompare, 0);
177065 int enc,
177077 rc = createCollation(db, zName, (u8)enc, pCtx, xCompare, xDel);
177090 int enc,
177104 rc = createCollation(db, zName8, (u8)enc, pCtx, xCompare, 0);
207145 int enc;
207147 enc = SQLITE_UTF8|SQLITE_DETERMINISTIC|SQLITE_INNOCUOUS;
207149 enc = SQLITE_UTF8|SQLITE_DIRECTONLY;
207152 enc, 0,
207856 unsigned int enc; /* Optimal text encoding */
207881 db, p->zName, p->nArg, p->enc,
218484 u8 enc /* String encoding (0 for blobs) */
218493 sqlite3ValueSetStr(pVal, nData, (char*)aCopy, enc, sqlite3_free);
218561 u8 enc = (eType==SQLITE_TEXT ? SQLITE_UTF8 : 0);
218562 rc = sessionValueSetStr(apOut[i],&pIn->aData[pIn->iNext],nByte,enc);