Lines Matching refs:pKeyInfo
13728 KeyInfo *pKeyInfo; /* Used when p4type is P4_KEYINFO */
15969 ** pKeyInfo->nField.
15979 ** at the first pKeyInfo->nFields,) then default_rc can be set to -1 to
15991 KeyInfo *pKeyInfo; /* Collation and sort-order information */
18745 KeyInfo *pKeyInfo; /* Info about index keys needed by index cursors */
59927 struct KeyInfo *pKeyInfo; /* Arg passed to comparison function */
61205 pIdxKey = sqlite3VdbeAllocUnpackedRecord(pCur->pKeyInfo);
61207 sqlite3VdbeRecordUnpack(pCur->pKeyInfo, (int)nKey, pKey, pIdxKey);
61218 sqlite3DbFree(pCur->pKeyInfo->db, pIdxKey);
64656 struct KeyInfo *pKeyInfo, /* First arg to comparison function */
64672 assert( hasSharedCacheTableLock(p, iTable, pKeyInfo!=0, (wrFlag?2:1)) );
64694 pCur->pKeyInfo = pKeyInfo;
64716 struct KeyInfo *pKeyInfo, /* First arg to xCompare() */
64724 rc = btreeCursor(p, iTable, wrFlag, pKeyInfo, pCur);
65455 /* If pCur->pKeyInfo is not NULL, then the caller that opened this cursor
65456 ** expected to open it on an index b-tree. Otherwise, if pKeyInfo is
65466 if( pRoot->isInit==0 || (pCur->pKeyInfo==0)!=pRoot->intKey ){
65650 assert( (pIdxKey==0)==(pCur->pKeyInfo==0) );
68599 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
68606 assert( (pX->pKey==0)==(pCur->pKeyInfo==0) );
68624 if( pCur->pKeyInfo==0 ){
68647 r.pKeyInfo = pCur->pKeyInfo;
68754 if( pCur->pKeyInfo ){
68806 assert( hasSharedCacheTableLock(p, pCur->pgnoRoot, pCur->pKeyInfo!=0, 2) );
68861 if( pCur->pKeyInfo==0 ){
72355 pRec->pKeyInfo = sqlite3KeyInfoOfIndex(p->pParse, pIdx);
72356 if( pRec->pKeyInfo ){
72357 assert( pRec->pKeyInfo->nAllField==nCol );
72358 assert( pRec->pKeyInfo->enc==ENC(db) );
72900 int nCol = pRec->pKeyInfo->nAllField;
72906 sqlite3KeyInfoUnref(pRec->pKeyInfo);
74019 KeyInfo *pKeyInfo;
74022 pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pIdx);
74023 if( pKeyInfo ) sqlite3VdbeAppendP4(v, pKeyInfo, P4_KEYINFO);
74285 KeyInfo *pKeyInfo = pOp->p4.pKeyInfo;
74286 assert( pKeyInfo->aSortOrder!=0 );
74287 sqlite3XPrintf(&x, "k(%d", pKeyInfo->nKeyField);
74288 for(j=0; j<pKeyInfo->nKeyField; j++){
74289 CollSeq *pColl = pKeyInfo->aColl[j];
74292 sqlite3XPrintf(&x, ",%s%s", pKeyInfo->aSortOrder[j] ? "-" : "", zColl);
76505 ** the first argument is a pointer to KeyInfo structure pKeyInfo.
76517 KeyInfo *pKeyInfo /* Description of the record */
76521 nByte = ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*(pKeyInfo->nKeyField+1);
76522 p = (UnpackedRecord *)sqlite3DbMallocRaw(pKeyInfo->db, nByte);
76525 assert( pKeyInfo->aSortOrder!=0 );
76526 p->pKeyInfo = pKeyInfo;
76527 p->nField = pKeyInfo->nKeyField + 1;
76537 KeyInfo *pKeyInfo, /* Information about the record format */
76558 pMem->enc = pKeyInfo->enc;
76559 pMem->db = pKeyInfo->db;
76567 assert( u<=pKeyInfo->nKeyField + 1 );
76594 KeyInfo *pKeyInfo;
76597 pKeyInfo = pPKey2->pKeyInfo;
76598 if( pKeyInfo->db==0 ) return 1;
76599 mem1.enc = pKeyInfo->enc;
76600 mem1.db = pKeyInfo->db;
76616 assert( pKeyInfo->nAllField>=pPKey2->nField || CORRUPT_DB );
76617 assert( pKeyInfo->aSortOrder!=0 );
76618 assert( pKeyInfo->nKeyField>0 );
76644 rc = sqlite3MemCompare(&mem1, &pPKey2->aMem[i], pKeyInfo->aColl[i]);
76647 if( pKeyInfo->aSortOrder[i] ){
76671 if( pKeyInfo->db->mallocFailed ) return 1;
76680 ** limit given by pKeyInfo->nAllField.
76690 const KeyInfo *pKeyInfo /* Compare size with this KeyInfo */
76706 assert( nField <= pKeyInfo->nAllField );
76973 ** malloc-failed flag set on database handle (pPKey2->pKeyInfo->db).
76986 KeyInfo *pKeyInfo = pPKey2->pKeyInfo;
77011 assert( pPKey2->pKeyInfo->nAllField>=pPKey2->nField
77013 assert( pPKey2->pKeyInfo->aSortOrder!=0 );
77014 assert( pPKey2->pKeyInfo->nKeyField>0 );
77081 }else if( pKeyInfo->aColl[i] ){
77082 mem1.enc = pKeyInfo->enc;
77083 mem1.db = pKeyInfo->db;
77087 &mem1, pRhs, pKeyInfo->aColl[i], &pPKey2->errCode
77132 if( pKeyInfo->aSortOrder[i] ){
77156 || pKeyInfo->db->mallocFailed
77190 vdbeAssertFieldCountWithinLimits(nKey1, pKey1, pPKey2->pKeyInfo);
77281 vdbeAssertFieldCountWithinLimits(nKey1, pKey1, pPKey2->pKeyInfo);
77323 || pPKey2->pKeyInfo->db->mallocFailed
77347 if( p->pKeyInfo->nAllField<=13 ){
77349 if( p->pKeyInfo->aSortOrder[0] ){
77362 if( (flags & (MEM_Real|MEM_Null|MEM_Blob))==0 && p->pKeyInfo->aColl[0]==0 ){
79445 KeyInfo *pKeyInfo,
79451 pRet = sqlite3VdbeAllocUnpackedRecord(pKeyInfo);
79453 memset(pRet->aMem, 0, sizeof(Mem)*(pKeyInfo->nKeyField+1));
79454 sqlite3VdbeRecordUnpack(pKeyInfo, nKey, pKey, pRet);
82058 const KeyInfo *pKeyInfo;
82074 pKeyInfo = pOp->p4.pKeyInfo;
82076 assert( pKeyInfo!=0 );
82096 assert( i<pKeyInfo->nKeyField );
82097 pColl = pKeyInfo->aColl[i];
82098 bRev = pKeyInfo->aSortOrder[i];
83382 KeyInfo *pKeyInfo;
83413 pKeyInfo = 0;
83446 pKeyInfo = pOp->p4.pKeyInfo;
83447 assert( pKeyInfo->enc==ENC(db) );
83448 assert( pKeyInfo->db==db );
83449 nField = pKeyInfo->nAllField;
83464 rc = sqlite3BtreeCursor(pX, p2, wrFlag, pKeyInfo, pCur->uc.pCursor);
83465 pCur->pKeyInfo = pKeyInfo;
83504 pCx->pKeyInfo = pOrig->pKeyInfo;
83507 pCx->pKeyInfo, pCx->uc.pCursor);
83545 KeyInfo *pKeyInfo;
83570 if( (pCx->pKeyInfo = pKeyInfo = pOp->p4.pKeyInfo)!=0 ){
83576 assert( pKeyInfo->db==db );
83577 assert( pKeyInfo->enc==ENC(db) );
83579 pKeyInfo, pCx->uc.pCursor);
83610 pCx->pKeyInfo = pOp->p4.pKeyInfo;
83611 assert( pCx->pKeyInfo->db==db );
83612 assert( pCx->pKeyInfo->enc==ENC(db) );
83888 r.pKeyInfo = pC->pKeyInfo;
84057 r.pKeyInfo = pC->pKeyInfo;
84074 pFree = pIdxKey = sqlite3VdbeAllocUnpackedRecord(pC->pKeyInfo);
84076 sqlite3VdbeRecordUnpack(pC->pKeyInfo, pIn3->n, pIn3->z, pIdxKey);
85201 r.pKeyInfo = pC->pKeyInfo;
85360 r.pKeyInfo = pC->pKeyInfo;
88126 KeyInfo *pKeyInfo; /* How to compare records */
88559 SortSubtask *pTask, /* Subtask context (for pKeyInfo) */
88566 sqlite3VdbeRecordUnpack(pTask->pSorter->pKeyInfo, nKey2, pKey2, r2);
88574 ** size nKey2 bytes). Use (pTask->pKeyInfo) for the collation sequences
88586 SortSubtask *pTask, /* Subtask context (for pKeyInfo) */
88593 sqlite3VdbeRecordUnpack(pTask->pSorter->pKeyInfo, nKey2, pKey2, r2);
88605 SortSubtask *pTask, /* Subtask context (for pKeyInfo) */
88627 if( pTask->pSorter->pKeyInfo->nKeyField>1 ){
88633 if( pTask->pSorter->pKeyInfo->aSortOrder[0] ){
88646 SortSubtask *pTask, /* Subtask context (for pKeyInfo) */
88696 if( pTask->pSorter->pKeyInfo->nKeyField>1 ){
88701 }else if( pTask->pSorter->pKeyInfo->aSortOrder[0] ){
88711 ** Usually, the sorter module uses the value of (pCsr->pKeyInfo->nKeyField)
88735 KeyInfo *pKeyInfo; /* Copy of pCsr->pKeyInfo with db==0 */
88736 int szKeyInfo; /* Size of pCsr->pKeyInfo in bytes */
88762 assert( pCsr->pKeyInfo && pCsr->pBtx==0 );
88764 szKeyInfo = sizeof(KeyInfo) + (pCsr->pKeyInfo->nKeyField-1)*sizeof(CollSeq*);
88772 pSorter->pKeyInfo = pKeyInfo = (KeyInfo*)((u8*)pSorter + sz);
88773 memcpy(pKeyInfo, pCsr->pKeyInfo, szKeyInfo);
88774 pKeyInfo->db = 0;
88776 pKeyInfo->nKeyField = nField;
88814 if( pKeyInfo->nAllField<13
88815 && (pKeyInfo->aColl[0]==0 || pKeyInfo->aColl[0]==db->pDfltColl)
89127 pTask->pUnpacked = sqlite3VdbeAllocUnpackedRecord(pTask->pSorter->pKeyInfo);
89129 pTask->pUnpacked->nField = pTask->pSorter->pKeyInfo->nKeyField;
90525 KeyInfo *pKeyInfo;
90532 pKeyInfo = pCsr->pKeyInfo;
90534 r2 = pSorter->pUnpacked = sqlite3VdbeAllocUnpackedRecord(pKeyInfo);
90541 sqlite3VdbeRecordUnpack(pKeyInfo, nKey, pKey, r2);
95277 KeyInfo *pKeyInfo = 0; /* Key information */
95299 pKeyInfo = isRowid ? 0 : sqlite3KeyInfoAlloc(pParse->db, nVal, 1);
95320 testcase( pKeyInfo==0 ); /* Caused by OOM in sqlite3KeyInfoAlloc() */
95323 sqlite3KeyInfoUnref(pKeyInfo);
95327 assert( pKeyInfo!=0 ); /* OOM will cause exit after sqlite3Select() */
95330 assert( sqlite3KeyInfoIsWriteable(pKeyInfo) );
95333 pKeyInfo->aColl[i] = sqlite3BinaryCompareCollSeq(
95356 if( pKeyInfo ){
95357 assert( sqlite3KeyInfoIsWriteable(pKeyInfo) );
95358 pKeyInfo->aColl[0] = sqlite3ExprCollSeq(pParse, pExpr->pLeft);
95399 if( pKeyInfo ){
95400 sqlite3VdbeChangeP4(v, addr, (void *)pKeyInfo, P4_KEYINFO);
119246 pKI = pOp->p4.pKeyInfo;
119250 pOp->p4.pKeyInfo = keyInfoFromExprList(pParse, pSort->pOrderBy, nOBSat,
120790 KeyInfo *pKeyInfo = multiSelectOrderByKeyInfo(pParse, p, 1);
120792 (char*)pKeyInfo, P4_KEYINFO);
121231 KeyInfo *pKeyInfo; /* Collating sequence for the result set */
121233 CollSeq **apColl; /* For looping through pKeyInfo->aColl[] */
121238 pKeyInfo = sqlite3KeyInfoAlloc(db, nCol, 1);
121239 if( !pKeyInfo ){
121243 for(i=0, apColl=pKeyInfo->aColl; i<nCol; i++, apColl++){
121260 sqlite3VdbeChangeP4(v, addr, (char*)sqlite3KeyInfoRef(pKeyInfo),
121265 sqlite3KeyInfoUnref(pKeyInfo);
121303 ** generated to suppress duplicates. pKeyInfo is used for comparing
121316 KeyInfo *pKeyInfo, /* For comparing with previous entry */
121332 (char*)sqlite3KeyInfoRef(pKeyInfo), P4_KEYINFO);
123467 KeyInfo *pKeyInfo = keyInfoFromExprList(pParse, pE->x.pList, 0, 0);
123469 (char*)pKeyInfo, P4_KEYINFO);
124182 KeyInfo *pKeyInfo;
124183 pKeyInfo = keyInfoFromExprList(pParse, sSort.pOrderBy, 0, pEList->nExpr);
124188 (char*)pKeyInfo, P4_KEYINFO
124376 KeyInfo *pKeyInfo; /* Keying information for the group by clause */
124392 pKeyInfo = keyInfoFromExprList(pParse, pGroupBy, 0, sAggInfo.nColumn);
124395 0, (char*)pKeyInfo, P4_KEYINFO);
124428 ** cancelled later because we still need to use the pKeyInfo
124519 (char*)sqlite3KeyInfoRef(pKeyInfo), P4_KEYINFO);
124619 KeyInfo *pKeyInfo = 0; /* Keyinfo for scanned index */
124647 pKeyInfo = sqlite3KeyInfoOfIndex(pParse, pBest);
124652 if( pKeyInfo ){
124653 sqlite3VdbeChangeP4(v, -1, (char *)pKeyInfo, P4_KEYINFO);
