Lines Matching defs:pKey
4783 const void *pKey, int nKey /* The key */
4796 const void *pKey, int nKey /* The new key */
7377 const char *pKey; int nKey; /* Key associated with this element */
7384 SQLITE_PRIVATE void *sqlite3HashInsert(Hash*, const char *pKey, int nKey, void *pData);
7385 SQLITE_PRIVATE void *sqlite3HashFind(const Hash*, const char *pKey, int nKey);
7403 /* #define sqliteHashKey(E) ((E)->pKey) // NOT USED */
8078 SQLITE_PRIVATE int sqlite3BtreeInsert(BtCursor*, const void *pKey, i64 nKey,
21925 unsigned int h = strHash(elem->pKey, elem->nKey) % new_size;
21938 const char *pKey, /* The key we are searching for */
21954 if( elem->nKey==nKey && sqlite3StrNICmp(elem->pKey,pKey,nKey)==0 ){
21997 ** that matches pKey,nKey. Return the data for this element if it is
22000 SQLITE_PRIVATE void *sqlite3HashFind(const Hash *pH, const char *pKey, int nKey){
22005 assert( pKey!=0 );
22008 h = strHash(pKey, nKey) % pH->htsize;
22012 elem = findElementGivenHash(pH, pKey, nKey, h);
22016 /* Insert an element into the hash table pH. The key is pKey,nKey
22030 SQLITE_PRIVATE void *sqlite3HashInsert(Hash *pH, const char *pKey, int nKey, void *data){
22036 assert( pKey!=0 );
22039 h = strHash(pKey, nKey) % pH->htsize;
22043 elem = findElementGivenHash(pH,pKey,nKey,h);
22050 elem->pKey = pKey;
22058 new_elem->pKey = pKey;
22065 h = strHash(pKey, nKey) % pH->htsize;
47834 i64 nKey; /* Size of pKey, or last integer key */
47835 void *pKey; /* Saved key that was cursor's last known position */
47864 ** in variables BtCursor.pKey and BtCursor.nKey. When a cursor is in
48822 ** and BtCursor.pKey. The cursor's state is set to CURSOR_REQUIRESEEK.
48831 assert( 0==pCur->pKey );
48844 void *pKey = sqlite3Malloc( (int)pCur->nKey );
48845 if( pKey ){
48846 rc = sqlite3BtreeKey(pCur, 0, (int)pCur->nKey, pKey);
48848 pCur->pKey = pKey;
48850 sqlite3_free(pKey);
48856 assert( !pCur->apPage[0]->intKey || !pCur->pKey );
48898 sqlite3_free(pCur->pKey);
48899 pCur->pKey = 0;
48904 ** In this version of BtreeMoveto, pKey is a packed index record
48910 const void *pKey, /* Packed key if the btree is an index */
48911 i64 nKey, /* Integer key for tables. Size of pKey for indices */
48920 if( pKey ){
48926 sqlite3VdbeRecordUnpack(pCur->pKeyInfo, (int)nKey, pKey, pIdxKey);
48952 rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &pCur->skipNext);
48954 sqlite3_free(pCur->pKey);
48955 pCur->pKey = 0;
53509 const void *pKey, i64 nKey, /* The key */
53557 if( NEVER(nKey>0x7fffffff || pKey==0) ){
53561 pSrc = pKey;
54916 ** Insert a new record into the BTree. The key is given by (pKey,nKey)
54921 ** For an INTKEY table, only the nKey value of the key is used. pKey is
54925 ** MovetoUnpacked() to seek cursor pCur to (pKey, nKey) has already
54927 ** number if pCur points at an entry that is smaller than (pKey, nKey), or
54929 ** (pKey, nKey)).
54939 const void *pKey, i64 nKey, /* The key of the new record */
54969 assert( (pKey==0)==(pCur->pKeyInfo==0) );
54992 rc = btreeMoveto(pCur, pKey, nKey, appendBias, &loc);
55008 rc = fillInCell(pPage, newCell, pKey, nKey, pData, nData, nZero, &szNew);
61181 ** Given the nKey-byte encoding of a record in pKey[], populate the
61188 const void *pKey, /* The binary record */
61191 const unsigned char *aKey = (const unsigned char *)pKey;
63890 Mem *pKey; /* MEM cell holding key for the record */
67537 Mem *pKey; /* MEM cell holding key for the record */
67558 u.bg.pKey = &aMem[pOp->p3];
67559 assert( u.bg.pKey->flags & MEM_Int );
67560 assert( memIsValid(u.bg.pKey) );
67561 REGISTER_TRACE(pOp->p3, u.bg.pKey);
67562 u.bg.iKey = u.bg.pKey->u.i;
71105 void *pKey;
71110 pKey = pIter->aKey;
71113 pKey = pSorter->pRecord->pVal;
71115 return pKey;
71123 void *pKey; int nKey; /* Sorter key to copy into pOut */
71125 pKey = vdbeSorterRowkey(pSorter, &nKey);
71131 memcpy(pOut->z, pKey, nKey);
71152 void *pKey; int nKey; /* Sorter key to compare pVal with */
71154 pKey = vdbeSorterRowkey(pSorter, &nKey);
71155 vdbeSorterCompare(pCsr, 1, pVal->z, pVal->n, pKey, nKey, pRes);
74513 char *pKey;
74515 pKey = (char *)sqlite3IndexKeyinfo(pParse, pIdx);
74519 pKey,P4_KEYINFO_HANDOFF);
77772 KeyInfo *pKey;
77776 pKey = sqlite3IndexKeyinfo(pParse, pIdx);
77784 (char *)pKey, P4_KEYINFO_HANDOFF);
78635 Expr *pKey /* Database key for encryption extension */
78649 SQLITE_OK!=(rc = resolveAttachExpr(&sName, pKey))
78675 sqlite3ExprCode(pParse, pKey, regArgs+2);
78694 sqlite3ExprDelete(db, pKey);
78722 ** ATTACH p AS pDbname KEY pKey
78724 SQLITE_PRIVATE void sqlite3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *pKey){
78738 codeAttach(pParse, SQLITE_ATTACH, &attach_func, p, p, pDbname, pKey);
81468 KeyInfo *pKey; /* KeyInfo for index */
81492 pKey = sqlite3IndexKeyinfo(pParse, pIndex);
81494 (char *)pKey, P4_KEYINFO_HANDOFF);
81502 sqlite3VdbeAddOp4(v, OP_SorterOpen, iSorter, 0, 0, (char*)pKey, P4_KEYINFO);
82917 KeyInfo *pKey = (KeyInfo *)sqlite3DbMallocZero(db, nBytes);
82919 if( pKey ){
82920 pKey->db = pParse->db;
82921 pKey->aSortOrder = (u8 *)&(pKey->aColl[nCol]);
82922 assert( &pKey->aSortOrder[nCol]==&(((u8 *)pKey)[nBytes]) );
82926 pKey->aColl[i] = sqlite3LocateCollSeq(pParse, zColl);
82927 pKey->aSortOrder[i] = pIdx->aSortOrder[i];
82929 pKey->nField = (u16)nCol;
82933 sqlite3DbFree(db, pKey);
82934 pKey = 0;
82936 return pKey;
86038 KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx);
86041 sqlite3VdbeChangeP4(v, -1, (char*)pKey, P4_KEYINFO_HANDOFF);
88381 KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx);
88384 (char*)pKey, P4_KEYINFO_HANDOFF);
88505 KeyInfo *pKey; /* Key information for an index */
88695 pKey = sqlite3IndexKeyinfo(pParse, pSrcIdx);
88697 (char*)pKey, P4_KEYINFO_HANDOFF);
88699 pKey = sqlite3IndexKeyinfo(pParse, pDestIdx);
88701 (char*)pKey, P4_KEYINFO_HANDOFF);
98619 KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIdx);
98621 (char*)pKey, P4_KEYINFO_HANDOFF);
105322 KeyInfo *pKey = sqlite3IndexKeyinfo(pParse, pIx);
105327 (char*)pKey, P4_KEYINFO_HANDOFF);
113976 void *pKey; int nKey; /* Key associated with this element */
113982 ** FTS3_HASH_STRING pKey points to a string that is nKey bytes long
113986 ** FTS3_HASH_BINARY pKey points to binary data nKey bytes long.
113998 SQLITE_PRIVATE void *sqlite3Fts3HashInsert(Fts3Hash*, const void *pKey, int nKey, void *pData);
113999 SQLITE_PRIVATE void *sqlite3Fts3HashFind(const Fts3Hash*, const void *pKey, int nKey);
114027 #define fts3HashKey(E) ((E)->pKey)
119921 const struct Fts3Keyword *pKey = &aKeyword[ii];
119923 if( (pKey->parenOnly & ~sqlite3_fts3_enable_parentheses)!=0 ){
119927 if( nInput>=pKey->n && 0==memcmp(zInput, pKey->z, pKey->n) ){
119929 int nKey = pKey->n;
119933 if( pKey->eType==FTSQUERY_NEAR ){
119955 pRet->eType = pKey->eType;
120588 if( pH->copyKey && elem->pKey ){
120589 fts3HashFree(elem->pKey);
120600 static int fts3StrHash(const void *pKey, int nKey){
120601 const char *z = (const char *)pKey;
120618 static int fts3BinHash(const void *pKey, int nKey){
120620 const char *z = (const char *)pKey;
120712 int h = (*xHash)(elem->pKey, elem->nKey) & (new_size-1);
120725 const void *pKey, /* The key we are searching for */
120739 if( (*xCompare)(elem->pKey,elem->nKey,pKey,nKey)==0 ){
120773 if( pH->copyKey && elem->pKey ){
120774 fts3HashFree(elem->pKey);
120787 const void *pKey,
120796 h = (*xHash)(pKey,nKey);
120798 return fts3FindElementByHash(pH,pKey,nKey, h & (pH->htsize-1));
120803 ** that matches pKey,nKey. Return the data for this element if it is
120806 SQLITE_PRIVATE void *sqlite3Fts3HashFind(const Fts3Hash *pH, const void *pKey, int nKey){
120809 pElem = sqlite3Fts3HashFindElem(pH, pKey, nKey);
120813 /* Insert an element into the hash table pH. The key is pKey,nKey
120830 const void *pKey, /* The key */
120843 hraw = (*xHash)(pKey, nKey);
120846 elem = fts3FindElementByHash(pH,pKey,nKey,h);
120866 if( pH->copyKey && pKey!=0 ){
120867 new_elem->pKey = fts3HashMalloc( nKey );
120868 if( new_elem->pKey==0 ){
120872 memcpy((void*)new_elem->pKey, pKey, nKey);
120874 new_elem->pKey = (void*)pKey;