Lines Matching refs:nKey
4589 const void *pKey, int nKey /* The key */
4602 const void *pKey, int nKey /* The new key */
7100 const char *pKey; int nKey; /* Key associated with this element */
7107 SQLITE_PRIVATE void *sqlite3HashInsert(Hash*, const char *pKey, int nKey, void *pData);
7108 SQLITE_PRIVATE void *sqlite3HashFind(const Hash*, const char *pKey, int nKey);
7127 /* #define sqliteHashKeysize(E) ((E)->nKey) // NOT USED */
7799 SQLITE_PRIVATE int sqlite3BtreeInsert(BtCursor*, const void *pKey, i64 nKey,
21441 static unsigned int strHash(const char *z, int nKey){
21443 assert( nKey>=0 );
21444 while( nKey > 0 ){
21446 nKey--;
21514 unsigned int h = strHash(elem->pKey, elem->nKey) % new_size;
21528 int nKey, /* Bytes in key (not counting zero terminator) */
21543 if( elem->nKey==nKey && sqlite3StrNICmp(elem->pKey,pKey,nKey)==0 ){
21586 ** that matches pKey,nKey. Return the data for this element if it is
21589 SQLITE_PRIVATE void *sqlite3HashFind(const Hash *pH, const char *pKey, int nKey){
21595 assert( nKey>=0 );
21597 h = strHash(pKey, nKey) % pH->htsize;
21601 elem = findElementGivenHash(pH, pKey, nKey, h);
21605 /* Insert an element into the hash table pH. The key is pKey,nKey
21619 SQLITE_PRIVATE void *sqlite3HashInsert(Hash *pH, const char *pKey, int nKey, void *data){
21626 assert( nKey>=0 );
21628 h = strHash(pKey, nKey) % pH->htsize;
21632 elem = findElementGivenHash(pH,pKey,nKey,h);
21640 assert(nKey==elem->nKey);
21648 new_elem->nKey = nKey;
21654 h = strHash(pKey, nKey) % pH->htsize;
46830 i64 nKey; /* The key for INTKEY tables, or number of bytes in key */
46873 i64 nKey; /* Size of pKey, or last integer key */
46878 u8 validNKey; /* True if info.nKey is valid */
46903 ** in variables BtCursor.pKey and BtCursor.nKey. When a cursor is in
47775 if( p->isIncrblobHandle && (isClearTable || p->info.nKey==iRow) ){
47860 ** Save the current cursor position in the variables BtCursor.nKey
47873 rc = sqlite3BtreeKeySize(pCur, &pCur->nKey);
47877 ** stores the integer key in pCur->nKey. In this case this value is
47879 ** table, then malloc space for and store the pCur->nKey bytes of key
47883 void *pKey = sqlite3Malloc( (int)pCur->nKey );
47885 rc = sqlite3BtreeKey(pCur, 0, (int)pCur->nKey, pKey);
47950 i64 nKey, /* Integer key for tables. Size of pKey for indices */
47959 assert( nKey==(i64)(int)nKey );
47960 pIdxKey = sqlite3VdbeRecordUnpack(pCur->pKeyInfo, (int)nKey, pKey,
47966 rc = sqlite3BtreeMovetoUnpacked(pCur, pIdxKey, nKey, bias, pRes);
47988 rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &pCur->skipNext);
48204 n += getVarint(&pCell[n], (u64*)&pInfo->nKey);
48209 pInfo->nKey = nPayload;
48338 assert( (info.nData+(pPage->intKey?0:info.nKey))==info.nPayload );
49703 ** 9-byte nKey value
50958 *pSize = pCur->info.nKey;
51128 u32 nKey;
51140 nKey = (pPage->intKey ? 0 : (int)pCur->info.nKey);
51142 if( NEVER(offset+amt > nKey+pCur->info.nData)
51326 u32 nKey;
51341 nKey = 0;
51343 nKey = (int)pCur->info.nKey;
51346 aPayload += nKey;
51347 nLocal = pCur->info.nLocal - nKey;
51350 assert( nLocal<=nKey );
51722 if( pCur->info.nKey==intKey ){
51726 if( pCur->atLast && pCur->info.nKey<intKey ){
51788 pCur->info.nKey = nCellKey;
51818 nCell = (int)pCur->info.nKey;
52529 const void *pKey, i64 nKey, /* The key */
52564 nHeader += putVarint(&pCell[nHeader], *(u64*)&nKey);
52567 assert( info.nKey==nKey );
52577 if( NEVER(nKey>0x7fffffff || pKey==0) ){
52580 nPayload += (int)nKey;
52582 nSrc = (int)nKey;
53545 sz = 4 + putVarint(&pCell[4], info.nKey);
53917 ** Insert a new record into the BTree. The key is given by (pKey,nKey)
53922 ** For an INTKEY table, only the nKey value of the key is used. pKey is
53926 ** MovetoUnpacked() to seek cursor pCur to (pKey, nKey) has already
53928 ** number if pCur points at an entry that is smaller than (pKey, nKey), or
53930 ** (pKey, nKey)).
53940 const void *pKey, i64 nKey, /* The key of the new record */
53976 invalidateIncrblobCursors(p, nKey, 0);
53993 rc = btreeMoveto(pCur, pKey, nKey, appendBias, &loc);
53999 assert( pPage->intKey || nKey>=0 );
54002 TRACE(("INSERT: table=%d nkey=%lld ndata=%d page=%d %s\n",
54003 pCur->pgnoRoot, nKey, nData, pPage->pgno,
54009 rc = fillInCell(pPage, newCell, pKey, nKey, pData, nData, nZero, &szNew);
54105 invalidateIncrblobCursors(p, pCur->info.nKey, 0);
54930 if( !pPage->intKey ) sz += (int)info.nKey;
54933 else if( i==0 ) nMinKey = nMaxKey = info.nKey;
54935 if( info.nKey <= nMaxKey ){
54937 "Rowid %lld out of order (previous was %lld)", info.nKey, nMaxKey);
54939 nMaxKey = info.nKey;
60096 ** Given the nKey-byte encoding of a record in pKey[], parse the
60110 int nKey, /* Size of the binary record */
60149 while( idx<szHdr && u<p->nField && d<=nKey ){
62912 int nKey;
66895 int nKey;
66909 u.bn.nKey = pIn2->n;
66911 rc = sqlite3BtreeInsert(u.bn.pCrsr, u.bn.zKey, u.bn.nKey, "", 0, 0, pOp->p3,
76381 int nKey;
76393 nKey = sqlite3_value_bytes(argv[2]);
76395 rc = sqlite3CodecAttach(db, db->nDb-1, zKey, nKey);
76400 sqlite3CodecGetKey(db, 0, (void**)&zKey, &nKey);
76401 if( nKey>0 || sqlite3BtreeGetReserve(db->aDb[0].pBt)>0 ){
76402 rc = sqlite3CodecAttach(db, db->nDb-1, zKey, nKey);
96744 int nKey;
96746 sqlite3CodecGetKey(db, 0, (void**)&zKey, &nKey);
96747 if( nKey ) db->nextPagesize = 0;
113121 void *pKey; int nKey; /* Key associated with this element */
113127 ** FTS3_HASH_STRING pKey points to a string that is nKey bytes long
113131 ** FTS3_HASH_BINARY pKey points to binary data nKey bytes long.
113143 SQLITE_PRIVATE void *sqlite3Fts3HashInsert(Fts3Hash*, const void *pKey, int nKey, void *pData);
113144 SQLITE_PRIVATE void *sqlite3Fts3HashFind(const Fts3Hash*, const void *pKey, int nKey);
113173 #define fts3HashKeysize(E) ((E)->nKey)
114113 int nKey;
114126 else if( isFts4 && fts3IsSpecialColumn(z, &nKey, &zVal) ){
114131 if( nKey==9 && 0==sqlite3_strnicmp(z, "matchinfo", 9) ){
114138 }else if( nKey==8 && 0==sqlite3_strnicmp(z, "compress", 8) ){
114141 }else if( nKey==10 && 0==sqlite3_strnicmp(z, "uncompress", 10) ){
117780 int nKey = pKey->n;
117785 assert( nKey==4 );
117788 for(nKey=5; zInput[nKey]>='0' && zInput[nKey]<='9'; nKey++){
117789 nNear = nNear * 10 + (zInput[nKey] - '0');
117798 cNext = zInput[nKey];
117809 *pnConsumed = (int)((zInput - z) + nKey);
118446 static int fts3StrHash(const void *pKey, int nKey){
118449 if( nKey<=0 ) nKey = (int) strlen(z);
118450 while( nKey > 0 ){
118452 nKey--;
118464 static int fts3BinHash(const void *pKey, int nKey){
118467 while( nKey-- > 0 ){
118558 int h = (*xHash)(elem->pKey, elem->nKey) & (new_size-1);
118572 int nKey,
118585 if( (*xCompare)(elem->pKey,elem->nKey,pKey,nKey)==0 ){
118634 int nKey
118642 h = (*xHash)(pKey,nKey);
118644 return fts3FindElementByHash(pH,pKey,nKey, h & (pH->htsize-1));
118649 ** that matches pKey,nKey. Return the data for this element if it is
118652 SQLITE_PRIVATE void *sqlite3Fts3HashFind(const Fts3Hash *pH, const void *pKey, int nKey){
118655 pElem = sqlite3Fts3HashFindElem(pH, pKey, nKey);
118659 /* Insert an element into the hash table pH. The key is pKey,nKey
118677 int nKey, /* Number of bytes in the key */
118689 hraw = (*xHash)(pKey, nKey);
118692 elem = fts3FindElementByHash(pH,pKey,nKey,h);
118713 new_elem->pKey = fts3HashMalloc( nKey );
118718 memcpy((void*)new_elem->pKey, pKey, nKey);
118722 new_elem->nKey = nKey;
121347 int nKey = fts3HashKeysize(pE);
121348 if( nTerm==0 || (nKey>=nTerm && 0==memcmp(zKey, zTerm, nTerm)) ){
