Lines Matching defs:pColl
7928 CollSeq *pColl; /* Used when p4type is P4_COLLSEQ */
9651 #define TF_NeedMetadata 0x20 /* aCol[].zType and aCol[].pColl missing */
10002 CollSeq *pColl; /* The collation type of the column or 0 */
12464 CollSeq *pColl; /* Collating sequence */
56739 ** sequence pColl and finally blob's ordered by memcmp().
56743 SQLITE_PRIVATE int sqlite3MemCompare(const Mem *pMem1, const Mem *pMem2, const CollSeq *pColl){
56814 assert( !pColl || pColl->xCmp );
56816 if( pColl ){
56817 if( pMem1->enc==pColl->enc ){
56820 return pColl->xCmp(pColl->pUser,pMem1->n,pMem1->z,pMem2->n,pMem2->z);
56830 v1 = sqlite3ValueText((sqlite3_value*)&c1, pColl->enc);
56832 v2 = sqlite3ValueText((sqlite3_value*)&c2, pColl->enc);
56834 rc = pColl->xCmp(pColl->pUser, n1, v1, n2, v2);
57988 CollSeq *pColl = pKeyInfo->aColl[j];
57989 if( pColl ){
57990 int n = sqlite3Strlen30(pColl->zName);
57999 memcpy(&zTemp[i], pColl->zName,n+1);
58012 CollSeq *pColl = pOp->p4.pColl;
58013 sqlite3_snprintf(nTemp, zTemp, "collseq(%.20s)", pColl->zName);
62537 CollSeq *pColl; /* Collating sequence to use on this term */
63720 u.ag.ctx.pColl = pOp[-1].p4.pColl;
64127 assert( pOp->p4type==P4_COLLSEQ || pOp->p4.pColl==0 );
64130 u.ai.res = sqlite3MemCompare(pIn3, pIn1, pOp->p4.pColl);
64195 CollSeq *pColl; /* Collating sequence to use on this term */
64223 u.aj.pColl = u.aj.pKeyInfo->aColl[u.aj.i];
64225 iCompare = sqlite3MemCompare(&aMem[u.aj.p1+u.aj.idx], &aMem[u.aj.p2+u.aj.idx], u.aj.pColl);
67609 u.cb.ctx.pColl = 0;
67614 u.cb.ctx.pColl = pOp[-1].p4.pColl;
69618 pDup->pColl = pExpr->pColl;
70320 CollSeq *pColl = pE->pColl;
70325 pE->pColl = pColl;
70799 SQLITE_PRIVATE Expr *sqlite3ExprSetColl(Expr *pExpr, CollSeq *pColl){
70800 if( pExpr && pColl ){
70801 pExpr->pColl = pColl;
70816 CollSeq *pColl;
70819 pColl = sqlite3LocateCollSeq(pParse, zColl);
70820 sqlite3ExprSetColl(pExpr, pColl);
70830 CollSeq *pColl = 0;
70834 pColl = p->pColl;
70835 if( pColl ) break;
70847 pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0);
70848 pExpr->pColl = pColl;
70857 if( sqlite3CheckCollSeq(pParse, pColl) ){
70858 pColl = 0;
70860 return pColl;
70957 CollSeq *pColl;
70960 assert( pLeft->pColl );
70961 pColl = pLeft->pColl;
70963 assert( pRight->pColl );
70964 pColl = pRight->pColl;
70966 pColl = sqlite3ExprCollSeq(pParse, pLeft);
70967 if( !pColl ){
70968 pColl = sqlite3ExprCollSeq(pParse, pRight);
70971 return pColl;
71195 pRoot->pColl = pRight->pColl;
71202 pRoot->pColl = pLeft->pColl;
71427 if( p->pLeft || p->pRight || p->pColl || p->x.pList ){
73272 CollSeq *pColl = 0; /* A collating sequence */
73343 if( (pDef->flags & SQLITE_FUNC_NEEDCOLL)!=0 && !pColl ){
73344 pColl = sqlite3ExprCollSeq(pParse, pFarg->a[i].pExpr);
73348 if( !pColl ) pColl = db->pDfltColl;
73349 sqlite3VdbeAddOp4(v, OP_CollSeq, 0, 0, 0, (char *)pColl, P4_COLLSEQ);
74198 if( (pA->flags & EP_ExpCollate)!=0 && pA->pColl!=pB->pColl ) return 2;
75564 CollSeq *pColl;
75603 pColl = sqlite3LocateCollSeq(pParse, pIdx->azColl[i]);
75605 (char*)pColl, P4_COLLSEQ);
78115 CollSeq *pColl;
78117 pColl = sqlite3FindCollSeq(db, enc, zName, initbusy);
78118 if( !initbusy && (!pColl || !pColl->xCmp) ){
78119 pColl = sqlite3GetCollSeq(db, enc, pColl, zName);
78120 if( !pColl ){
78125 return pColl;
79415 CollSeq *pColl = pExpr->pColl;
79416 /* Either pColl!=0 or there was an OOM failure. But if an OOM
79418 if( ALWAYS(pColl) ){
79419 nExtra += (1 + sqlite3Strlen30(pColl->zName));
79489 /* Justification of the ALWAYS(pListItem->pExpr->pColl): Because of
79491 ** if pListItem->pExpr is not null then either pListItem->pExpr->pColl
79494 if( pListItem->pExpr && ALWAYS(pListItem->pExpr->pColl) ){
79496 zColl = pListItem->pExpr->pColl->zName;
80433 ** Check to see if pIndex uses the collating sequence pColl. Return
80452 ** Recompute all indices of pTab that use the collating sequence pColl.
80453 ** If pColl==0 then recompute all indices of pTab.
80471 ** indices use the collating sequence pColl. If pColl==0 then recompute
80508 CollSeq *pColl; /* Collating sequence to be reindexed, or NULL */
80531 pColl = sqlite3FindCollSeq(db, ENC(db), zColl, 0);
80532 if( pColl ){
80650 static int synthCollSeq(sqlite3 *db, CollSeq *pColl){
80652 char *z = pColl->zName;
80658 memcpy(pColl, pColl2, sizeof(CollSeq));
80659 pColl->xDel = 0; /* Do not copy the destructor */
80671 ** If it is not NULL, then pColl must point to the database native encoding
80683 CollSeq *pColl, /* Collating sequence with native encoding, or NULL */
80688 p = pColl;
80717 SQLITE_PRIVATE int sqlite3CheckCollSeq(Parse *pParse, CollSeq *pColl){
80718 if( pColl ){
80719 const char *zName = pColl->zName;
80721 CollSeq *p = sqlite3GetCollSeq(db, ENC(db), pColl, zName);
80727 assert( p==pColl );
80752 CollSeq *pColl;
80754 pColl = sqlite3HashFind(&db->aCollSeq, zName, nName);
80756 if( 0==pColl && create ){
80757 pColl = sqlite3DbMallocZero(db, 3*sizeof(*pColl) + nName + 1 );
80758 if( pColl ){
80760 pColl[0].zName = (char*)&pColl[3];
80761 pColl[0].enc = SQLITE_UTF8;
80762 pColl[1].zName = (char*)&pColl[3];
80763 pColl[1].enc = SQLITE_UTF16LE;
80764 pColl[2].zName = (char*)&pColl[3];
80765 pColl[2].enc = SQLITE_UTF16BE;
80766 memcpy(pColl[0].zName, zName, nName);
80767 pColl[0].zName[nName] = 0;
80768 pDel = sqlite3HashInsert(&db->aCollSeq, pColl[0].zName, nName, pColl);
80771 ** return the pColl pointer to be deleted (because it wasn't added
80774 assert( pDel==0 || pDel==pColl );
80778 pColl = 0;
80782 return pColl;
80806 CollSeq *pColl;
80808 pColl = findCollSeqEntry(db, zName, create);
80810 pColl = db->pDfltColl;
80814 if( pColl ) pColl += enc-1;
80815 return pColl;
81727 return context->pColl;
81741 CollSeq *pColl;
81745 pColl = sqlite3GetFuncCollSeq(context);
81746 assert( pColl );
81752 if( (sqlite3MemCompare(argv[iBest], argv[i], pColl)^mask)>=0 ){
82438 CollSeq *pColl = sqlite3GetFuncCollSeq(context);
82440 if( sqlite3MemCompare(argv[0], argv[1], pColl)!=0 ){
83030 CollSeq *pColl = sqlite3GetFuncCollSeq(context);
83040 cmp = sqlite3MemCompare(pBest, pArg, pColl);
83799 pLeft->pColl = sqlite3LocateCollSeq(pParse, pCol->zColl);
88515 CollSeq *pColl = (CollSeq *)sqliteHashData(p);
88517 sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pColl->zName, 0);
90684 CollSeq *pColl;
90685 pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
90686 if( !pColl ){
90687 pColl = db->pDfltColl;
90689 pInfo->aColl[i] = pColl;
91242 CollSeq *pColl;
91259 pColl = sqlite3ExprCollSeq(pParse, p);
91260 if( pColl ){
91261 pCol->zColl = sqlite3DbStrDup(db, pColl->zName);
92151 CollSeq *pColl;
92154 pColl = pTerm->pColl;
92156 pColl = multiSelectCollSeq(pParse, p, aPermute[i]);
92158 pTerm->pColl = pColl;
92160 pKeyMerge->aColl[i] = pColl;
92428 if( pNew && pExpr->pColl ){
92429 pNew->pColl = pExpr->pColl;
93506 CollSeq *pColl = 0;
93510 for(j=0, pItem=pList->a; !pColl && j<nArg; j++, pItem++){
93511 pColl = sqlite3ExprCollSeq(pParse, pItem->pExpr);
93513 if( !pColl ){
93514 pColl = pParse->db->pDfltColl;
93516 sqlite3VdbeAddOp4(v, OP_CollSeq, 0, 0, 0, (char *)pColl, P4_COLLSEQ);
98174 pExpr->pRight->pColl = sqlite3ExprCollSeq(pParse, pExpr->pRight);
98175 pExpr->pLeft->pColl = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
98176 SWAP(CollSeq*,pExpr->pRight->pColl,pExpr->pLeft->pColl);
98240 CollSeq *pColl;
98250 ** value in variable pColl.
98253 pColl = sqlite3BinaryCompareCollSeq(pParse, pX->pLeft, pX->pRight);
98254 assert(pColl || pParse->nErr);
98259 if( pColl && sqlite3StrICmp(pColl->zName, pIdx->azColl[j]) ) continue;
98907 CollSeq *pColl; /* Collating sequence to use */
98929 pColl = sqlite3FindCollSeq(db, SQLITE_UTF8, noCase ? "NOCASE" : "BINARY",0);
98931 sqlite3ExprSetColl(sqlite3ExprDup(db,pLeft,0), pColl),
98937 sqlite3ExprSetColl(sqlite3ExprDup(db,pLeft,0), pColl),
99109 CollSeq *pColl; /* The collating sequence of pExpr */
99121 pColl = sqlite3ExprCollSeq(pParse, pExpr);
99122 if( !pColl ){
99123 pColl = db->pDfltColl;
99135 zColl = pColl->zName;
99137 if( pExpr->iColumn!=iColumn || sqlite3StrICmp(pColl->zName, zColl) ){
99474 CollSeq *pColl; /* Collating sequence to on a column */
99551 pColl = sqlite3BinaryCompareCollSeq(pParse, pX->pLeft, pX->pRight);
99552 pIdx->azColl[n] = ALWAYS(pColl) ? pColl->zName : "BINARY";
99961 CollSeq *pColl;
99970 pColl = db->pDfltColl;
99971 assert( pColl->enc==SQLITE_UTF8 );
99973 pColl = sqlite3GetCollSeq(db, SQLITE_UTF8, 0, *pIdx->azColl);
99974 if( pColl==0 ){
99979 z = (const u8 *)sqlite3ValueText(pVal, pColl->enc);
99983 assert( z && pColl && pColl->xCmp );
99985 n = sqlite3ValueBytes(pVal, pColl->enc);
99993 if( pColl->enc!=SQLITE_UTF8 ){
99996 db, pColl->enc, aSample[i].u.z, aSample[i].nByte, &nSample
100002 c = pColl->xCmp(pColl->pUser, nSample, zSample, n, z);
100007 c = pColl->xCmp(pColl->pUser, aSample[i].nByte, aSample[i].u.z, n, z);
108001 CollSeq *pColl = (CollSeq *)sqliteHashData(i);
108004 if( pColl[j].xDel ){
108005 pColl[j].xDel(pColl[j].pUser);
108008 sqlite3DbFree(db, pColl);
108866 CollSeq *pColl;
108890 pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 0);
108891 if( pColl && pColl->xCmp ){
108899 /* If collation sequence pColl was created directly by a call to
108905 if( (pColl->enc & ~SQLITE_UTF16_ALIGNED)==enc2 ){
108910 if( p->enc==pColl->enc ){
108920 pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 1);
108921 if( pColl==0 ) return SQLITE_NOMEM;
108922 pColl->xCmp = xCompare;
108923 pColl->pUser = pCtx;
108924 pColl->xDel = xDel;
108925 pColl->enc = (u8)(enc2 | (enc & SQLITE_UTF16_ALIGNED));
108926 pColl->type = collType;