Lines Matching defs:pKeyInfo
16504 KeyInfo *pKeyInfo; /* Used when p4type is P4_KEYINFO */
18649 ** pKeyInfo->nField.
18659 ** at the first pKeyInfo->nFields,) then default_rc can be set to -1 to
18671 KeyInfo *pKeyInfo; /* Collation and sort-order information */
23222 KeyInfo *pKeyInfo; /* Info about index keys needed by index cursors */
70060 struct KeyInfo *pKeyInfo; /* Arg passed to comparison function */
71414 KeyInfo *pKeyInfo = pCur->pKeyInfo;
71416 pIdxKey = sqlite3VdbeAllocUnpackedRecord(pKeyInfo);
71418 sqlite3VdbeRecordUnpack(pKeyInfo, (int)nKey, pKey, pIdxKey);
71419 if( pIdxKey->nField==0 || pIdxKey->nField>pKeyInfo->nAllField ){
71424 sqlite3DbFree(pCur->pKeyInfo->db, pIdxKey);
75190 struct KeyInfo *pKeyInfo, /* First arg to comparison function */
75206 assert( hasSharedCacheTableLock(p, iTable, pKeyInfo!=0, (wrFlag?2:1))
75229 pCur->pKeyInfo = pKeyInfo;
75257 struct KeyInfo *pKeyInfo, /* First arg to comparison function */
75262 rc = btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur);
75270 struct KeyInfo *pKeyInfo, /* First arg to xCompare() */
75274 return btreeCursorWithLock(p, iTable, wrFlag, pKeyInfo, pCur);
75276 return btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur);
76068 /* If pCur->pKeyInfo is not NULL, then the caller that opened this cursor
76069 ** expected to open it on an index b-tree. Otherwise, if pKeyInfo is
76079 if( pRoot->isInit==0 || (pCur->pKeyInfo==0)!=pRoot->intKey ){
76262 assert( pCur->pKeyInfo==0 );
76494 assert( pCur->pKeyInfo!=0 );
79853 assert( (flags & BTREE_PREFORMAT)==0 || seekResult || pCur->pKeyInfo==0 );
79893 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
79900 assert( (flags & BTREE_PREFORMAT) || (pX->pKey==0)==(pCur->pKeyInfo==0) );
79902 if( pCur->pKeyInfo==0 ){
79961 r.pKeyInfo = pCur->pKeyInfo;
80121 if( pCur->pKeyInfo ){
80168 if( pDest->pKeyInfo==0 ) aOut += putVarint(aOut, iKey);
80284 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
80366 if( pCur->pKeyInfo==0 && p->hasIncrblobCur ){
84229 pRec->pKeyInfo = sqlite3KeyInfoOfIndex(p->pParse, pIdx);
84230 if( pRec->pKeyInfo ){
84231 assert( pRec->pKeyInfo->nAllField==nCol );
84232 assert( pRec->pKeyInfo->enc==ENC(db) );
84774 int nCol = pRec->pKeyInfo->nAllField;
84780 sqlite3KeyInfoUnref(pRec->pKeyInfo);
86457 KeyInfo *pKeyInfo;
86460 pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pIdx);
86461 if( pKeyInfo ) sqlite3VdbeAppendP4(v, pKeyInfo, P4_KEYINFO);
86739 KeyInfo *pKeyInfo = pOp->p4.pKeyInfo;
86740 assert( pKeyInfo->aSortFlags!=0 );
86741 sqlite3_str_appendf(&x, "k(%d", pKeyInfo->nKeyField);
86742 for(j=0; j<pKeyInfo->nKeyField; j++){
86743 CollSeq *pColl = pKeyInfo->aColl[j];
86747 (pKeyInfo->aSortFlags[j] & KEYINFO_ORDER_DESC) ? "-" : "",
86748 (pKeyInfo->aSortFlags[j] & KEYINFO_ORDER_BIGNULL)? "N." : "",
89021 ** the first argument is a pointer to KeyInfo structure pKeyInfo.
89033 KeyInfo *pKeyInfo /* Description of the record */
89037 nByte = ROUND8P(sizeof(UnpackedRecord)) + sizeof(Mem)*(pKeyInfo->nKeyField+1);
89038 p = (UnpackedRecord *)sqlite3DbMallocRaw(pKeyInfo->db, nByte);
89041 assert( pKeyInfo->aSortFlags!=0 );
89042 p->pKeyInfo = pKeyInfo;
89043 p->nField = pKeyInfo->nKeyField + 1;
89053 KeyInfo *pKeyInfo, /* Information about the record format */
89074 pMem->enc = pKeyInfo->enc;
89075 pMem->db = pKeyInfo->db;
89091 assert( u<=pKeyInfo->nKeyField + 1 );
89118 KeyInfo *pKeyInfo;
89121 pKeyInfo = pPKey2->pKeyInfo;
89122 if( pKeyInfo->db==0 ) return 1;
89123 mem1.enc = pKeyInfo->enc;
89124 mem1.db = pKeyInfo->db;
89140 assert( pKeyInfo->nAllField>=pPKey2->nField || CORRUPT_DB );
89141 assert( pKeyInfo->aSortFlags!=0 );
89142 assert( pKeyInfo->nKeyField>0 );
89179 pKeyInfo->nAllField>i ? pKeyInfo->aColl[i] : 0);
89182 if( (pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_BIGNULL)
89187 if( pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_DESC ){
89211 if( pKeyInfo->db->mallocFailed ) return 1;
89220 ** limit given by pKeyInfo->nAllField.
89230 const KeyInfo *pKeyInfo /* Compare size with this KeyInfo */
89246 assert( nField <= pKeyInfo->nAllField );
89538 ** malloc-failed flag set on database handle (pPKey2->pKeyInfo->db).
89551 KeyInfo *pKeyInfo;
89584 assert( pPKey2->pKeyInfo->nAllField>=pPKey2->nField
89586 assert( pPKey2->pKeyInfo->aSortFlags!=0 );
89587 assert( pPKey2->pKeyInfo->nKeyField>0 );
89658 || (pKeyInfo = pPKey2->pKeyInfo)->nAllField<=i
89662 }else if( pKeyInfo->aColl[i] ){
89663 mem1.enc = pKeyInfo->enc;
89664 mem1.db = pKeyInfo->db;
89668 &mem1, pRhs, pKeyInfo->aColl[i], &pPKey2->errCode
89720 int sortFlags = pPKey2->pKeyInfo->aSortFlags[i];
89756 || pPKey2->pKeyInfo->db->mallocFailed
89790 vdbeAssertFieldCountWithinLimits(nKey1, pKey1, pPKey2->pKeyInfo);
89884 vdbeAssertFieldCountWithinLimits(nKey1, pKey1, pPKey2->pKeyInfo);
89933 || pPKey2->pKeyInfo->db->mallocFailed
89957 if( p->pKeyInfo->nAllField<=13 ){
89959 if( p->pKeyInfo->aSortFlags[0] ){
89960 if( p->pKeyInfo->aSortFlags[0] & KEYINFO_ORDER_BIGNULL ){
89977 && p->pKeyInfo->aColl[0]==0
92516 KeyInfo *pKeyInfo,
92522 pRet = sqlite3VdbeAllocUnpackedRecord(pKeyInfo);
92524 memset(pRet->aMem, 0, sizeof(Mem)*(pKeyInfo->nKeyField+1));
92525 sqlite3VdbeRecordUnpack(pKeyInfo, nKey, pKey, pRet);
93835 if( len > 4000 && pC->pKeyInfo==0 ){
95549 const KeyInfo *pKeyInfo;
95565 pKeyInfo = pOp->p4.pKeyInfo;
95567 assert( pKeyInfo!=0 );
95587 assert( i<pKeyInfo->nKeyField );
95588 pColl = pKeyInfo->aColl[i];
95589 bRev = (pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_DESC);
95593 if( (pKeyInfo->aSortFlags[i] & KEYINFO_ORDER_BIGNULL)
97392 KeyInfo *pKeyInfo;
97425 pKeyInfo = 0;
97459 pKeyInfo = pOp->p4.pKeyInfo;
97460 assert( pKeyInfo->enc==ENC(db) );
97461 assert( pKeyInfo->db==db );
97462 nField = pKeyInfo->nAllField;
97478 rc = sqlite3BtreeCursor(pX, p2, wrFlag, pKeyInfo, pCur->uc.pCursor);
97479 pCur->pKeyInfo = pKeyInfo;
97517 pCx->pKeyInfo = pOrig->pKeyInfo;
97525 pCx->pKeyInfo, pCx->uc.pCursor);
97570 KeyInfo *pKeyInfo;
97613 if( (pCx->pKeyInfo = pKeyInfo = pOp->p4.pKeyInfo)!=0 ){
97619 assert( pKeyInfo->db==db );
97620 assert( pKeyInfo->enc==ENC(db) );
97622 pKeyInfo, pCx->uc.pCursor);
97660 pCx->pKeyInfo = pOp->p4.pKeyInfo;
97661 assert( pCx->pKeyInfo->db==db );
97662 assert( pCx->pKeyInfo->enc==ENC(db) );
97958 r.pKeyInfo = pC->pKeyInfo;
98156 r.pKeyInfo = pC->pKeyInfo;
98409 r.pKeyInfo = pC->pKeyInfo;
98426 pIdxKey = sqlite3VdbeAllocUnpackedRecord(pC->pKeyInfo);
98428 sqlite3VdbeRecordUnpack(pC->pKeyInfo, r.aMem->n, r.aMem->z, pIdxKey);
99648 r.pKeyInfo = pC->pKeyInfo;
99830 r.pKeyInfo = pC->pKeyInfo;
103126 KeyInfo *pKeyInfo; /* How to compare records */
103559 SortSubtask *pTask, /* Subtask context (for pKeyInfo) */
103566 sqlite3VdbeRecordUnpack(pTask->pSorter->pKeyInfo, nKey2, pKey2, r2);
103574 ** size nKey2 bytes). Use (pTask->pKeyInfo) for the collation sequences
103586 SortSubtask *pTask, /* Subtask context (for pKeyInfo) */
103593 sqlite3VdbeRecordUnpack(pTask->pSorter->pKeyInfo, nKey2, pKey2, r2);
103605 SortSubtask *pTask, /* Subtask context (for pKeyInfo) */
103627 if( pTask->pSorter->pKeyInfo->nKeyField>1 ){
103633 assert( !(pTask->pSorter->pKeyInfo->aSortFlags[0]&KEYINFO_ORDER_BIGNULL) );
103634 if( pTask->pSorter->pKeyInfo->aSortFlags[0] ){
103647 SortSubtask *pTask, /* Subtask context (for pKeyInfo) */
103697 if( pTask->pSorter->pKeyInfo->nKeyField>1 ){
103702 }else if( pTask->pSorter->pKeyInfo->aSortFlags[0] ){
103703 assert( !(pTask->pSorter->pKeyInfo->aSortFlags[0]&KEYINFO_ORDER_BIGNULL) );
103713 ** Usually, the sorter module uses the value of (pCsr->pKeyInfo->nKeyField)
103737 KeyInfo *pKeyInfo; /* Copy of pCsr->pKeyInfo with db==0 */
103738 int szKeyInfo; /* Size of pCsr->pKeyInfo in bytes */
103764 assert( pCsr->pKeyInfo );
103767 szKeyInfo = sizeof(KeyInfo) + (pCsr->pKeyInfo->nKeyField-1)*sizeof(CollSeq*);
103776 pSorter->pKeyInfo = pKeyInfo = (KeyInfo*)((u8*)pSorter + sz);
103777 memcpy(pKeyInfo, pCsr->pKeyInfo, szKeyInfo);
103778 pKeyInfo->db = 0;
103780 pKeyInfo->nKeyField = nField;
103820 if( pKeyInfo->nAllField<13
103821 && (pKeyInfo->aColl[0]==0 || pKeyInfo->aColl[0]==db->pDfltColl)
103822 && (pKeyInfo->aSortFlags[0] & KEYINFO_ORDER_BIGNULL)==0
104135 pTask->pUnpacked = sqlite3VdbeAllocUnpackedRecord(pTask->pSorter->pKeyInfo);
104137 pTask->pUnpacked->nField = pTask->pSorter->pKeyInfo->nKeyField;
105541 KeyInfo *pKeyInfo;
105548 pKeyInfo = pCsr->pKeyInfo;
105550 r2 = pSorter->pUnpacked = sqlite3VdbeAllocUnpackedRecord(pKeyInfo);
105557 sqlite3VdbeRecordUnpack(pKeyInfo, nKey, pKey, r2);
112439 KeyInfo *pKeyInfo = 0; /* Key information */
112503 pKeyInfo = sqlite3KeyInfoAlloc(pParse->db, nVal, 1);
112528 testcase( pKeyInfo==0 ); /* Caused by OOM in sqlite3KeyInfoAlloc() */
112534 sqlite3KeyInfoUnref(pKeyInfo);
112537 assert( pKeyInfo!=0 ); /* OOM will cause exit after sqlite3Select() */
112540 assert( sqlite3KeyInfoIsWriteable(pKeyInfo) );
112543 pKeyInfo->aColl[i] = sqlite3BinaryCompareCollSeq(
112567 if( pKeyInfo ){
112568 assert( sqlite3KeyInfoIsWriteable(pKeyInfo) );
112569 pKeyInfo->aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
112598 if( pKeyInfo ){
112599 sqlite3VdbeChangeP4(v, addr, (void *)pKeyInfo, P4_KEYINFO);
143667 pKI = pOp->p4.pKeyInfo;
143671 pOp->p4.pKeyInfo = sqlite3KeyInfoFromExprList(pParse,pSort->pOrderBy,nOBSat,
144097 pOp->p4.pKeyInfo->nAllField += (pExtra->nExpr - pSort->nDefer);
145583 KeyInfo *pKeyInfo = multiSelectOrderByKeyInfo(pParse, p, 1);
145585 (char*)pKeyInfo, P4_KEYINFO);
146065 KeyInfo *pKeyInfo; /* Collating sequence for the result set */
146067 CollSeq **apColl; /* For looping through pKeyInfo->aColl[] */
146073 pKeyInfo = sqlite3KeyInfoAlloc(db, nCol, 1);
146074 if( !pKeyInfo ){
146078 for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){
146095 sqlite3VdbeChangeP4(v, addr, (char*)sqlite3KeyInfoRef(pKeyInfo),
146100 sqlite3KeyInfoUnref(pKeyInfo);
146141 ** generated to suppress duplicates. pKeyInfo is used for comparing
146154 KeyInfo *pKeyInfo, /* For comparing with previous entry */
146170 (char*)sqlite3KeyInfoRef(pKeyInfo), P4_KEYINFO);
149578 KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pE->x.pList,0,0);
149580 pFunc->iDistinct, 0, 0, (char*)pKeyInfo, P4_KEYINFO);
149587 KeyInfo *pKeyInfo;
149605 pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pOBList, 0, nExtra);
149607 pKeyInfo->nKeyField++;
149611 (char*)pKeyInfo, P4_KEYINFO);
150771 KeyInfo *pKeyInfo;
150772 pKeyInfo = sqlite3KeyInfoFromExprList(
150778 (char*)pKeyInfo, P4_KEYINFO
151025 KeyInfo *pKeyInfo; /* Keying information for the group by clause */
151057 pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pGroupBy,
151061 0, (char*)pKeyInfo, P4_KEYINFO);
151103 ** cancelled later because we still need to use the pKeyInfo
151217 (char*)sqlite3KeyInfoRef(pKeyInfo), P4_KEYINFO);
151324 KeyInfo *pKeyInfo = 0; /* Keyinfo for scanned index */
151354 pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pBest);
151359 if( pKeyInfo ){
151360 sqlite3VdbeChangeP4(v, -1, (char *)pKeyInfo, P4_KEYINFO);
153966 KeyInfo *pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pPk);
153967 if( pKeyInfo ){
153968 pKeyInfo->nAllField = nEphCol;
153969 sqlite3VdbeAppendP4(v, pKeyInfo, P4_KEYINFO);
170782 KeyInfo *pKeyInfo;
170785 pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pList, 0, 0);
170789 if( pKeyInfo && pWin->pWFunc->zName[1]=='i' ){
170790 assert( pKeyInfo->aSortFlags[0]==0 );
170791 pKeyInfo->aSortFlags[0] = KEYINFO_ORDER_DESC;
170794 sqlite3VdbeAppendP4(v, pKeyInfo, P4_KEYINFO);
171210 KeyInfo *pKeyInfo = 0;
171213 pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pMWin->pOrderBy, 0, 0);
171219 if( pKeyInfo ){
171222 sqlite3VdbeAppendP4(v, (void*)pKeyInfo, P4_KEYINFO);
171408 KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pOrderBy, 0, 0);
171410 sqlite3VdbeAppendP4(v, (void*)pKeyInfo, P4_KEYINFO);
172261 KeyInfo *pKeyInfo = sqlite3KeyInfoFromExprList(pParse, pPart, 0, 0);
172265 sqlite3VdbeAppendP4(v, (void*)pKeyInfo, P4_KEYINFO);