Lines Matching refs:pKeyInfo
15591 KeyInfo *pKeyInfo; /* Used when p4type is P4_KEYINFO */
17884 ** pKeyInfo->nField.
17894 ** at the first pKeyInfo->nFields,) then default_rc can be set to -1 to
17906 KeyInfo *pKeyInfo; /* Collation and sort-order information */
21101 KeyInfo *pKeyInfo; /* Info about index keys needed by index cursors */
64477 struct KeyInfo *pKeyInfo; /* Arg passed to comparison function */
65779 KeyInfo *pKeyInfo = pCur->pKeyInfo;
65781 pIdxKey = sqlite3VdbeAllocUnpackedRecord(pKeyInfo);
65783 sqlite3VdbeRecordUnpack(pKeyInfo, (int)nKey, pKey, pIdxKey);
65784 if( pIdxKey->nField==0 || pIdxKey->nField>pKeyInfo->nAllField ){
65794 sqlite3DbFree(pCur->pKeyInfo->db, pIdxKey);
69366 struct KeyInfo *pKeyInfo, /* First arg to comparison function */
69382 assert( hasSharedCacheTableLock(p, iTable, pKeyInfo!=0, (wrFlag?2:1))
69409 pCur->pKeyInfo = pKeyInfo;
69431 struct KeyInfo *pKeyInfo, /* First arg to comparison function */
69436 rc = btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur);
69444 struct KeyInfo *pKeyInfo, /* First arg to xCompare() */
69448 return btreeCursorWithLock(p, iTable, wrFlag, pKeyInfo, pCur);
69450 return btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur);
70225 /* If pCur->pKeyInfo is not NULL, then the caller that opened this cursor
70226 ** expected to open it on an index b-tree. Otherwise, if pKeyInfo is
70236 if( pRoot->isInit==0 || (pCur->pKeyInfo==0)!=pRoot->intKey ){
70421 assert( (pIdxKey==0)==(pCur->pKeyInfo==0) );
73653 assert( (flags & BTREE_PREFORMAT)==0 || seekResult || pCur->pKeyInfo==0 );
73664 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
73671 assert( (flags & BTREE_PREFORMAT) || (pX->pKey==0)==(pCur->pKeyInfo==0) );
73689 if( pCur->pKeyInfo==0 ){
73745 r.pKeyInfo = pCur->pKeyInfo;
73900 if( pCur->pKeyInfo ){
73944 if( pDest->pKeyInfo==0 ) aOut += putVarint(aOut, iKey);
74060 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
74120 if( pCur->pKeyInfo==0 ){
77806 pRec->pKeyInfo = sqlite3KeyInfoOfIndex(p->pParse, pIdx);
77807 if( pRec->pKeyInfo ){
77808 assert( pRec->pKeyInfo->nAllField==nCol );
77809 assert( pRec->pKeyInfo->enc==ENC(db) );
78317 int nCol = pRec->pKeyInfo->nAllField;
78323 sqlite3KeyInfoUnref(pRec->pKeyInfo);
79740 KeyInfo *pKeyInfo;
79743 pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pIdx);
79744 if( pKeyInfo ) sqlite3VdbeAppendP4(v, pKeyInfo, P4_KEYINFO);
80020 KeyInfo *pKeyInfo = pOp->p4.pKeyInfo;
80021 assert( pKeyInfo->aSortFlags!=0 );
80022 sqlite3_str_appendf(&x, "k(%d", pKeyInfo->nKeyField);
80023 for(j=0; j<pKeyInfo->nKeyField; j++){
80024 CollSeq *pColl = pKeyInfo->aColl[j];
80028 (pKeyInfo->aSortFlags[j] & KEYINFO_ORDER_DESC) ? "-" : "",
80029 (pKeyInfo->aSortFlags[j] & KEYINFO_ORDER_BIGNULL)? "N." : "",
82360 ** the first argument is a pointer to KeyInfo structure pKeyInfo.
82372 KeyInfo *pKeyInfo /* Description of the record */
82376 nByte = ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*(pKeyInfo->nKeyField+1);
82377 p = (UnpackedRecord *)sqlite3DbMallocRaw(pKeyInfo->db, nByte);
82380 assert( pKeyInfo->aSortFlags!=0 );
82381 p->pKeyInfo = pKeyInfo;
82382 p->nField = pKeyInfo->nKeyField + 1;
82392 KeyInfo *pKeyInfo, /* Information about the record format */
82413 pMem->enc = pKeyInfo->enc;
82414 pMem->db = pKeyInfo->db;
82429 assert( u<=pKeyInfo->nKeyField + 1 );
82456 KeyInfo *pKeyInfo;
82459 pKeyInfo = pPKey2->pKeyInfo;
82460 if( pKeyInfo->db==0 ) return 1;
82461 mem1.enc = pKeyInfo->enc;
82462 mem1.db = pKeyInfo->db;
82478 assert( pKeyInfo->nAllField>=pPKey2->nField || CORRUPT_DB );
82479 assert( pKeyInfo->aSortFlags!=0 );
82480 assert( pKeyInfo->nKeyField>0 );
82507 pKeyInfo->nAllField>i ? pKeyInfo->aColl[i] : 0);
82510 if( (pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_BIGNULL)
82515 if( pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_DESC ){
82539 if( pKeyInfo->db->mallocFailed ) return 1;
82548 ** limit given by pKeyInfo->nAllField.
82558 const KeyInfo *pKeyInfo /* Compare size with this KeyInfo */
82574 assert( nField <= pKeyInfo->nAllField );
82854 ** malloc-failed flag set on database handle (pPKey2->pKeyInfo->db).
82867 KeyInfo *pKeyInfo;
82892 assert( pPKey2->pKeyInfo->nAllField>=pPKey2->nField
82894 assert( pPKey2->pKeyInfo->aSortFlags!=0 );
82895 assert( pPKey2->pKeyInfo->nKeyField>0 );
82962 || (pKeyInfo = pPKey2->pKeyInfo)->nAllField<=i
82966 }else if( pKeyInfo->aColl[i] ){
82967 mem1.enc = pKeyInfo->enc;
82968 mem1.db = pKeyInfo->db;
82972 &mem1, pRhs, pKeyInfo->aColl[i], &pPKey2->errCode
83017 int sortFlags = pPKey2->pKeyInfo->aSortFlags[i];
83048 || pPKey2->pKeyInfo->db->mallocFailed
83082 vdbeAssertFieldCountWithinLimits(nKey1, pKey1, pPKey2->pKeyInfo);
83173 vdbeAssertFieldCountWithinLimits(nKey1, pKey1, pPKey2->pKeyInfo);
83218 || pPKey2->pKeyInfo->db->mallocFailed
83242 if( p->pKeyInfo->nAllField<=13 ){
83244 if( p->pKeyInfo->aSortFlags[0] ){
83245 if( p->pKeyInfo->aSortFlags[0] & KEYINFO_ORDER_BIGNULL ){
83261 && p->pKeyInfo->aColl[0]==0
85430 KeyInfo *pKeyInfo,
85436 pRet = sqlite3VdbeAllocUnpackedRecord(pKeyInfo);
85438 memset(pRet->aMem, 0, sizeof(Mem)*(pKeyInfo->nKeyField+1));
85439 sqlite3VdbeRecordUnpack(pKeyInfo, nKey, pKey, pRet);
88208 const KeyInfo *pKeyInfo;
88224 pKeyInfo = pOp->p4.pKeyInfo;
88226 assert( pKeyInfo!=0 );
88246 assert( i<pKeyInfo->nKeyField );
88247 pColl = pKeyInfo->aColl[i];
88248 bRev = (pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_DESC);
88251 if( (pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_BIGNULL)
89722 KeyInfo *pKeyInfo;
89753 pKeyInfo = 0;
89787 pKeyInfo = pOp->p4.pKeyInfo;
89788 assert( pKeyInfo->enc==ENC(db) );
89789 assert( pKeyInfo->db==db );
89790 nField = pKeyInfo->nAllField;
89805 rc = sqlite3BtreeCursor(pX, p2, wrFlag, pKeyInfo, pCur->uc.pCursor);
89806 pCur->pKeyInfo = pKeyInfo;
89844 pCx->pKeyInfo = pOrig->pKeyInfo;
89852 pCx->pKeyInfo, pCx->uc.pCursor);
89897 KeyInfo *pKeyInfo;
89940 if( (pCx->pKeyInfo = pKeyInfo = pOp->p4.pKeyInfo)!=0 ){
89946 assert( pKeyInfo->db==db );
89947 assert( pKeyInfo->enc==ENC(db) );
89949 pKeyInfo, pCx->uc.pCursor);
89987 pCx->pKeyInfo = pOp->p4.pKeyInfo;
89988 assert( pCx->pKeyInfo->db==db );
89989 assert( pCx->pKeyInfo->enc==ENC(db) );
90282 r.pKeyInfo = pC->pKeyInfo;
90441 r.pKeyInfo = pC->pKeyInfo;
90673 r.pKeyInfo = pC->pKeyInfo;
90690 pFree = pIdxKey = sqlite3VdbeAllocUnpackedRecord(pC->pKeyInfo);
90692 sqlite3VdbeRecordUnpack(pC->pKeyInfo, pIn3->n, pIn3->z, pIdxKey);
91867 r.pKeyInfo = pC->pKeyInfo;
92048 r.pKeyInfo = pC->pKeyInfo;
95072 KeyInfo *pKeyInfo; /* How to compare records */
95505 SortSubtask *pTask, /* Subtask context (for pKeyInfo) */
95512 sqlite3VdbeRecordUnpack(pTask->pSorter->pKeyInfo, nKey2, pKey2, r2);
95520 ** size nKey2 bytes). Use (pTask->pKeyInfo) for the collation sequences
95532 SortSubtask *pTask, /* Subtask context (for pKeyInfo) */
95539 sqlite3VdbeRecordUnpack(pTask->pSorter->pKeyInfo, nKey2, pKey2, r2);
95551 SortSubtask *pTask, /* Subtask context (for pKeyInfo) */
95573 if( pTask->pSorter->pKeyInfo->nKeyField>1 ){
95579 assert( !(pTask->pSorter->pKeyInfo->aSortFlags[0]&KEYINFO_ORDER_BIGNULL) );
95580 if( pTask->pSorter->pKeyInfo->aSortFlags[0] ){
95593 SortSubtask *pTask, /* Subtask context (for pKeyInfo) */
95643 if( pTask->pSorter->pKeyInfo->nKeyField>1 ){
95648 }else if( pTask->pSorter->pKeyInfo->aSortFlags[0] ){
95649 assert( !(pTask->pSorter->pKeyInfo->aSortFlags[0]&KEYINFO_ORDER_BIGNULL) );
95659 ** Usually, the sorter module uses the value of (pCsr->pKeyInfo->nKeyField)
95683 KeyInfo *pKeyInfo; /* Copy of pCsr->pKeyInfo with db==0 */
95684 int szKeyInfo; /* Size of pCsr->pKeyInfo in bytes */
95710 assert( pCsr->pKeyInfo && pCsr->pBtx==0 );
95712 szKeyInfo = sizeof(KeyInfo) + (pCsr->pKeyInfo->nKeyField-1)*sizeof(CollSeq*);
95721 pSorter->pKeyInfo = pKeyInfo = (KeyInfo*)((u8*)pSorter + sz);
95722 memcpy(pKeyInfo, pCsr->pKeyInfo, szKeyInfo);
95723 pKeyInfo->db = 0;
95725 pKeyInfo->nKeyField = nField;
95765 if( pKeyInfo->nAllField<13
95766 && (pKeyInfo->aColl[0]==0 || pKeyInfo->aColl[0]==db->pDfltColl)
95767 && (pKeyInfo->aSortFlags[0] & KEYINFO_ORDER_BIGNULL)==0
96079 pTask->pUnpacked = sqlite3VdbeAllocUnpackedRecord(pTask->pSorter->pKeyInfo);
96081 pTask->pUnpacked->nField = pTask->pSorter->pKeyInfo->nKeyField;
97484 KeyInfo *pKeyInfo;
97491 pKeyInfo = pCsr->pKeyInfo;
97493 r2 = pSorter->pUnpacked = sqlite3VdbeAllocUnpackedRecord(pKeyInfo);
97500 sqlite3VdbeRecordUnpack(pKeyInfo, nKey, pKey, r2);
103522 KeyInfo *pKeyInfo = 0; /* Key information */
103584 pKeyInfo = sqlite3KeyInfoAlloc(pParse->db, nVal, 1);
103607 testcase( pKeyInfo==0 ); /* Caused by OOM in sqlite3KeyInfoAlloc() */
103610 sqlite3KeyInfoUnref(pKeyInfo);
103614 assert( pKeyInfo!=0 ); /* OOM will cause exit after sqlite3Select() */
103617 assert( sqlite3KeyInfoIsWriteable(pKeyInfo) );
103620 pKeyInfo->aColl[i] = sqlite3BinaryCompareCollSeq(
103644 if( pKeyInfo ){
103645 assert( sqlite3KeyInfoIsWriteable(pKeyInfo) );
103646 pKeyInfo->aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
103674 if( pKeyInfo ){
103675 sqlite3VdbeChangeP4(v, addr, (void *)pKeyInfo, P4_KEYINFO);
131825 pKI = pOp->p4.pKeyInfo;
131829 pOp->p4.pKeyInfo = sqlite3KeyInfoFromExprList(pParse,pSort->pOrderBy,nOBSat,
132121 pOp->p4.pKeyInfo->nAllField += (pExtra->nExpr - pSort->nDefer);
133568 KeyInfo *pKeyInfo = multiSelectOrderByKeyInfo(pParse, p, 1);
133570 (char*)pKeyInfo, P4_KEYINFO);
134045 KeyInfo *pKeyInfo; /* Collating sequence for the result set */
134047 CollSeq **apColl; /* For looping through pKeyInfo->aColl[] */
134052 pKeyInfo = sqlite3KeyInfoAlloc(db, nCol, 1);
134053 if( !pKeyInfo ){
134057 for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){
134074 sqlite3VdbeChangeP4(v, addr, (char*)sqlite3KeyInfoRef(pKeyInfo),
134079 sqlite3KeyInfoUnref(pKeyInfo);
134118 ** generated to suppress duplicates. pKeyInfo is used for comparing
134131 KeyInfo *pKeyInfo, /* For comparing with previous entry */
134147 (char*)sqlite3KeyInfoRef(pKeyInfo), P4_KEYINFO);
136805 KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pE->x.pList,0,0);
136807 (char*)pKeyInfo, P4_KEYINFO);
137651 KeyInfo *pKeyInfo;
137652 pKeyInfo = sqlite3KeyInfoFromExprList(
137658 (char*)pKeyInfo, P4_KEYINFO
137914 KeyInfo *pKeyInfo; /* Keying information for the group by clause */
137930 pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pGroupBy,
137934 0, (char*)pKeyInfo, P4_KEYINFO);
137967 ** cancelled later because we still need to use the pKeyInfo
138055 (char*)sqlite3KeyInfoRef(pKeyInfo), P4_KEYINFO);
138157 KeyInfo *pKeyInfo = 0; /* Keyinfo for scanned index */
138187 pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pBest);
138192 if( pKeyInfo ){
138193 sqlite3VdbeChangeP4(v, -1, (char *)pKeyInfo, P4_KEYINFO);
140595 KeyInfo *pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pPk);
140596 if( pKeyInfo ){
140597 pKeyInfo->nAllField = nEphCol;
140598 sqlite3VdbeAppendP4(v, pKeyInfo, P4_KEYINFO);
155338 KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pList, 0, 0);
155342 if( pKeyInfo && pWin->pFunc->zName[1]=='i' ){
155343 assert( pKeyInfo->aSortFlags[0]==0 );
155344 pKeyInfo->aSortFlags[0] = KEYINFO_ORDER_DESC;
155347 sqlite3VdbeAppendP4(v, pKeyInfo, P4_KEYINFO);
155757 KeyInfo *pKeyInfo = 0;
155760 pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pMWin->pOrderBy, 0, 0);
155766 if( pKeyInfo ){
155769 sqlite3VdbeAppendP4(v, (void*)pKeyInfo, P4_KEYINFO);
155954 KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pOrderBy, 0, 0);
155956 sqlite3VdbeAppendP4(v, (void*)pKeyInfo, P4_KEYINFO);
156796 KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pPart, 0, 0);
156800 sqlite3VdbeAppendP4(v, (void*)pKeyInfo, P4_KEYINFO);