Lines Matching defs:pKey
14450 const char *pKey; /* Key associated with this element */
14457 SQLITE_PRIVATE void *sqlite3HashInsert(Hash*, const char *pKey, void *pData);
14458 SQLITE_PRIVATE void *sqlite3HashFind(const Hash*, const char *pKey);
14476 /* #define sqliteHashKey(E) ((E)->pKey) // NOT USED */
16294 ** an arbitrary key and no data. These btrees have pKey,nKey set to the
16300 ** the key and passed in the nKey field. The pKey field is zero.
16309 ** pKey always NULL encoded key
16310 ** nKey the ROWID length of pKey
16324 const void *pKey; /* Key content for indexes. NULL for tables */
16325 sqlite3_int64 nKey; /* Size of pKey for indexes. PRIMARY KEY for tabs */
16327 sqlite3_value *aMem; /* First of nMem value in the unpacked pKey */
37029 unsigned int h = strHash(elem->pKey) % new_size;
37043 const char *pKey, /* The key we are searching for */
37053 h = strHash(pKey) % pH->htsize;
37065 if( sqlite3StrICmp(elem->pKey,pKey)==0 ){
37109 ** that matches pKey. Return the data for this element if it is
37112 SQLITE_PRIVATE void *sqlite3HashFind(const Hash *pH, const char *pKey){
37114 assert( pKey!=0 );
37115 return findElementWithHash(pH, pKey, 0)->data;
37118 /* Insert an element into the hash table pH. The key is pKey
37132 SQLITE_PRIVATE void *sqlite3HashInsert(Hash *pH, const char *pKey, void *data){
37138 assert( pKey!=0 );
37139 elem = findElementWithHash(pH,pKey,&h);
37146 elem->pKey = pKey;
37153 new_elem->pKey = pKey;
37159 h = strHash(pKey) % pH->htsize;
70046 void *pKey; /* Saved key that was cursor last known position */
70054 i64 nKey; /* Size of pKey, or last integer key */
70095 ** in variables BtCursor.pKey and BtCursor.nKey. When a cursor is in
71248 ** pCur->pKey. SQLITE_OK is returned if successful or an SQLite error
71252 ** (the rowid) is stored in pCur->nKey and pCur->pKey is left set to
71253 ** NULL. If the cursor is open on a non-intkey table, then pCur->pKey is
71260 assert( 0==pCur->pKey );
71273 void *pKey;
71275 pKey = sqlite3Malloc( pCur->nKey + 9 + 8 );
71276 if( pKey ){
71277 rc = sqlite3BtreePayload(pCur, 0, (int)pCur->nKey, pKey);
71279 memset(((u8*)pKey)+pCur->nKey, 0, 9+8);
71280 pCur->pKey = pKey;
71282 sqlite3_free(pKey);
71288 assert( !pCur->curIntKey || !pCur->pKey );
71294 ** and BtCursor.pKey. The cursor's state is set to CURSOR_REQUIRESEEK.
71303 assert( 0==pCur->pKey );
71393 sqlite3_free(pCur->pKey);
71394 pCur->pKey = 0;
71399 ** In this version of BtreeMoveto, pKey is a packed index record
71405 const void *pKey, /* Packed key if the btree is an index */
71406 i64 nKey, /* Integer key for tables. Size of pKey for indices */
71413 if( pKey ){
71418 sqlite3VdbeRecordUnpack(pKeyInfo, (int)nKey, pKey, pIdxKey);
71451 rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &skipNext);
71454 sqlite3_free(pCur->pKey);
71455 pCur->pKey = 0;
75329 sqlite3_free(pCur->pKey);
77552 assert( pX->nKey<=0x7fffffff && pX->pKey!=0 );
77554 pSrc = pX->pKey;
79814 ** the key is used. The pX.pKey value must be NULL. The pX.nKey is the
79819 ** key is an arbitrary byte sequence stored in pX.pKey,nKey. The
79823 ** sqlite3BtreeIndexMoveto() to seek cursor pCur to (pKey,nKey) has already
79827 ** smaller then (pKey,nKey). If seekResult>0 then pCur points to a cell
79828 ** that is larger than (pKey,nKey).
79832 ** point for (pKey,nKey) before doing the insertion. For index btrees,
79834 ** key values and pX->aMem can be used instead of pX->pKey to avoid having
79900 assert( (flags & BTREE_PREFORMAT) || (pX->pKey==0)==(pCur->pKeyInfo==0) );
79903 assert( pX->pKey==0 );
79968 rc = btreeMoveto(pCur, pX->pKey, pX->nKey,
79982 x2.pData = pX->pKey;
80122 assert( pCur->pKey==0 );
80123 pCur->pKey = sqlite3Malloc( pX->nKey );
80124 if( pCur->pKey==0 ){
80127 memcpy(pCur->pKey, pX->pKey, pX->nKey);
89048 ** Given the nKey-byte encoding of a record in pKey[], populate the
89055 const void *pKey, /* The binary record */
89058 const unsigned char *aKey = (const unsigned char *)pKey;
89219 ** pKey,nKey. The verify that this count is less than or equal to the
89229 int nKey, const void *pKey, /* The record to verify */
89236 const unsigned char *aKey = (const unsigned char*)pKey;
92512 ** record in nKey/pKey. Return a pointer to the new UnpackedRecord structure
92518 const void *pKey
92525 sqlite3VdbeRecordUnpack(pKeyInfo, nKey, pKey, pRet);
98769 Mem *pKey; /* MEM cell holding key for the record */
98789 pKey = &aMem[pOp->p3];
98790 assert( pKey->flags & MEM_Int );
98791 assert( memIsValid(pKey) );
98792 REGISTER_TRACE(pOp->p3, pKey);
98793 x.nKey = pKey->u.i;
98833 x.pKey = 0;
99580 x.pKey = pIn2->z;
105477 void *pKey;
105489 pKey = pReader->aKey;
105492 pKey = SRVAL(pSorter->list.pList);
105494 return pKey;
105502 void *pKey; int nKey; /* Sorter key to copy into pOut */
105506 pKey = vdbeSorterRowkey(pSorter, &nKey);
105512 memcpy(pOut->z, pKey, nKey);
105543 void *pKey; int nKey; /* Sorter key to compare pVal with */
105556 pKey = vdbeSorterRowkey(pSorter, &nKey);
105557 sqlite3VdbeRecordUnpack(pKeyInfo, nKey, pKey, r2);
120825 Expr *pKey /* Database key for encryption extension */
120842 SQLITE_OK!=resolveAttachExpr(&sName, pKey)
120868 sqlite3ExprCode(pParse, pKey, regArgs+2);
120884 sqlite3ExprDelete(db, pKey);
120910 ** ATTACH p AS pDbname KEY pKey
120912 SQLITE_PRIVATE void sqlite3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *pKey){
120924 codeAttach(pParse, SQLITE_ATTACH, &attach_func, p, p, pDbname, pKey);
125131 KeyInfo *pKey; /* KeyInfo for index */
125153 pKey = sqlite3KeyInfoOfIndex(pParse, pIndex);
125154 assert( pKey!=0 || pParse->nErr );
125159 sqlite3KeyInfoRef(pKey), P4_KEYINFO);
125175 (char *)pKey, P4_KEYINFO);
126921 KeyInfo *pKey;
126924 pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey);
126926 pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0);
126928 if( pKey ){
126929 assert( sqlite3KeyInfoIsWriteable(pKey) );
126932 pKey->aColl[i] = zColl==sqlite3StrBINARY ? 0 :
126934 pKey->aSortFlags[i] = pIdx->aSortOrder[i];
126935 assert( 0==(pKey->aSortFlags[i] & KEYINFO_ORDER_BIGNULL) );
126950 sqlite3KeyInfoUnref(pKey);
126951 pKey = 0;
126954 return pKey;
185763 void *pKey; int nKey; /* Key associated with this element */
185769 ** FTS3_HASH_STRING pKey points to a string that is nKey bytes long
185773 ** FTS3_HASH_BINARY pKey points to binary data nKey bytes long.
185785 SQLITE_PRIVATE void *sqlite3Fts3HashInsert(Fts3Hash*, const void *pKey, int nKey, void *pData);
185786 SQLITE_PRIVATE void *sqlite3Fts3HashFind(const Fts3Hash*, const void *pKey, int nKey);
185814 #define fts3HashKey(E) ((E)->pKey)
193336 const struct Fts3Keyword *pKey = &aKeyword[ii];
193338 if( (pKey->parenOnly & ~sqlite3_fts3_enable_parentheses)!=0 ){
193342 if( nInput>=pKey->n && 0==memcmp(zInput, pKey->z, pKey->n) ){
193344 int nKey = pKey->n;
193348 if( pKey->eType==FTSQUERY_NEAR ){
193367 pRet->eType = pKey->eType;
194283 if( pH->copyKey && elem->pKey ){
194284 fts3HashFree(elem->pKey);
194295 static int fts3StrHash(const void *pKey, int nKey){
194296 const char *z = (const char *)pKey;
194313 static int fts3BinHash(const void *pKey, int nKey){
194315 const char *z = (const char *)pKey;
194407 int h = (*xHash)(elem->pKey, elem->nKey) & (new_size-1);
194420 const void *pKey, /* The key we are searching for */
194434 if( (*xCompare)(elem->pKey,elem->nKey,pKey,nKey)==0 ){
194468 if( pH->copyKey && elem->pKey ){
194469 fts3HashFree(elem->pKey);
194482 const void *pKey,
194491 h = (*xHash)(pKey,nKey);
194493 return fts3FindElementByHash(pH,pKey,nKey, h & (pH->htsize-1));
194498 ** that matches pKey,nKey. Return the data for this element if it is
194501 SQLITE_PRIVATE void *sqlite3Fts3HashFind(const Fts3Hash *pH, const void *pKey, int nKey){
194504 pElem = sqlite3Fts3HashFindElem(pH, pKey, nKey);
194508 /* Insert an element into the hash table pH. The key is pKey,nKey
194525 const void *pKey, /* The key */
194538 hraw = (*xHash)(pKey, nKey);
194541 elem = fts3FindElementByHash(pH,pKey,nKey,h);
194561 if( pH->copyKey && pKey!=0 ){
194562 new_elem->pKey = fts3HashMalloc( nKey );
194563 if( new_elem->pKey==0 ){
194567 memcpy((void*)new_elem->pKey, pKey, nKey);
194569 new_elem->pKey = (void*)pKey;