Lines Matching defs:nKey
4589 const void *pKey, int nKey /* The key */
4602 const void *pKey, int nKey /* The new key */
7085 const char *pKey; int nKey; /* Key associated with this element */
7092 SQLITE_PRIVATE void *sqlite3HashInsert(Hash*, const char *pKey, int nKey, void *pData);
7093 SQLITE_PRIVATE void *sqlite3HashFind(const Hash*, const char *pKey, int nKey);
7112 /* #define sqliteHashKeysize(E) ((E)->nKey) // NOT USED */
7784 SQLITE_PRIVATE int sqlite3BtreeInsert(BtCursor*, const void *pKey, i64 nKey,
21426 static unsigned int strHash(const char *z, int nKey){
21428 assert( nKey>=0 );
21429 while( nKey > 0 ){
21431 nKey--;
21499 unsigned int h = strHash(elem->pKey, elem->nKey) % new_size;
21513 int nKey, /* Bytes in key (not counting zero terminator) */
21528 if( elem->nKey==nKey && sqlite3StrNICmp(elem->pKey,pKey,nKey)==0 ){
21571 ** that matches pKey,nKey. Return the data for this element if it is
21574 SQLITE_PRIVATE void *sqlite3HashFind(const Hash *pH, const char *pKey, int nKey){
21580 assert( nKey>=0 );
21582 h = strHash(pKey, nKey) % pH->htsize;
21586 elem = findElementGivenHash(pH, pKey, nKey, h);
21590 nKey
21604 SQLITE_PRIVATE void *sqlite3HashInsert(Hash *pH, const char *pKey, int nKey, void *data){
21611 assert( nKey>=0 );
21613 h = strHash(pKey, nKey) % pH->htsize;
21617 elem = findElementGivenHash(pH,pKey,nKey,h);
21625 assert(nKey==elem->nKey);
21633 new_elem->nKey = nKey;
21639 h = strHash(pKey, nKey) % pH->htsize;
46651 i64 nKey; /* The key for INTKEY tables, or number of bytes in key */
46694 i64 nKey; /* Size of pKey, or last integer key */
46699 u8 validNKey; /* True if info.nKey is valid */
46724 ** in variables BtCursor.pKey and BtCursor.nKey. When a cursor is in
47596 if( p->isIncrblobHandle && (isClearTable || p->info.nKey==iRow) ){
47681 ** Save the current cursor position in the variables BtCursor.nKey
47694 rc = sqlite3BtreeKeySize(pCur, &pCur->nKey);
47698 ** stores the integer key in pCur->nKey. In this case this value is
47700 ** table, then malloc space for and store the pCur->nKey bytes of key
47704 void *pKey = sqlite3Malloc( (int)pCur->nKey );
47706 rc = sqlite3BtreeKey(pCur, 0, (int)pCur->nKey, pKey);
47771 i64 nKey, /* Integer key for tables. Size of pKey for indices */
47780 assert( nKey==(i64)(int)nKey );
47781 pIdxKey = sqlite3VdbeRecordUnpack(pCur->pKeyInfo, (int)nKey, pKey,
47787 rc = sqlite3BtreeMovetoUnpacked(pCur, pIdxKey, nKey, bias, pRes);
47809 rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &pCur->skipNext);
48025 n += getVarint(&pCell[n], (u64*)&pInfo->nKey);
48030 pInfo->nKey = nPayload;
48159 assert( (info.nData+(pPage->intKey?0:info.nKey))==info.nPayload );
49524 ** 9-byte nKey value
50779 *pSize = pCur->info.nKey;
50949 u32 nKey;
50961 nKey = (pPage->intKey ? 0 : (int)pCur->info.nKey);
50963 if( NEVER(offset+amt > nKey+pCur->info.nData)
51147 u32 nKey;
51162 nKey = 0;
51164 nKey = (int)pCur->info.nKey;
51167 aPayload += nKey;
51168 nLocal = pCur->info.nLocal - nKey;
51171 assert( nLocal<=nKey );
51543 if( pCur->info.nKey==intKey ){
51547 if( pCur->atLast && pCur->info.nKey<intKey ){
51609 pCur->info.nKey = nCellKey;
51639 nCell = (int)pCur->info.nKey;
52350 const void *pKey, i64 nKey, /* The key */
52385 nHeader += putVarint(&pCell[nHeader], *(u64*)&nKey);
52388 assert( info.nKey==nKey );
52398 if( NEVER(nKey>0x7fffffff || pKey==0) ){
52401 nPayload += (int)nKey;
52403 nSrc = (int)nKey;
53366 sz = 4 + putVarint(&pCell[4], info.nKey);
53738 ** Insert a new record into the BTree. The key is given by (pKey,nKey)
53743 ** For an INTKEY table, only the nKey value of the key is used. pKey is
53747 ** MovetoUnpacked() to seek cursor pCur to (pKey, nKey) has already
53749 ** number if pCur points at an entry that is smaller than (pKey, nKey), or
53751 ** (pKey, nKey)).
53761 const void *pKey, i64 nKey, /* The key of the new record */
53797 invalidateIncrblobCursors(p, nKey, 0);
53814 rc = btreeMoveto(pCur, pKey, nKey, appendBias, &loc);
53820 assert( pPage->intKey || nKey>=0 );
53823 TRACE(("INSERT: table=%d nkey=%lld ndata=%d page=%d %s\n",
53824 pCur->pgnoRoot, nKey, nData, pPage->pgno,
53830 rc = fillInCell(pPage, newCell, pKey, nKey, pData, nData, nZero, &szNew);
53926 invalidateIncrblobCursors(p, pCur->info.nKey, 0);
54751 if( !pPage->intKey ) sz += (int)info.nKey;
54754 else if( i==0 ) nMinKey = nMaxKey = info.nKey;
54756 if( info.nKey <= nMaxKey ){
54758 "Rowid %lld out of order (previous was %lld)", info.nKey, nMaxKey);
54760 nMaxKey = info.nKey;
59917 ** Given the nKey-byte encoding of a record in pKey[], parse the
59931 int nKey, /* Size of the binary record */
59970 while( idx<szHdr && u<p->nField && d<=nKey ){
62733 int nKey;
66716 int nKey;
66730 u.bn.nKey = pIn2->n;
66732 rc = sqlite3BtreeInsert(u.bn.pCrsr, u.bn.zKey, u.bn.nKey, "", 0, 0, pOp->p3,
76202 int nKey;
76214 nKey = sqlite3_value_bytes(argv[2]);
76216 rc = sqlite3CodecAttach(db, db->nDb-1, zKey, nKey);
76221 sqlite3CodecGetKey(db, 0, (void**)&zKey, &nKey);
76222 if( nKey>0 || sqlite3BtreeGetReserve(db->aDb[0].pBt)>0 ){
76223 rc = sqlite3CodecAttach(db, db->nDb-1, zKey, nKey);
96537 int nKey;
96539 sqlite3CodecGetKey(db, 0, (void**)&zKey, &nKey);
96540 if( nKey ) db->nextPagesize = 0;
112942 void *pKey; int nKey; /* Key associated with this element */
112948 ** FTS3_HASH_STRING pKey points to a string that is nKey bytes long
112952 ** FTS3_HASH_BINARY pKey points to binary data nKey bytes long.
112964 SQLITE_PRIVATE void *sqlite3Fts3HashInsert(Fts3Hash*, const void *pKey, int nKey, void *pData);
112965 SQLITE_PRIVATE void *sqlite3Fts3HashFind(const Fts3Hash*, const void *pKey, int nKey);
112994 #define fts3HashKeysize(E) ((E)->nKey)
113934 int nKey;
113947 else if( isFts4 && fts3IsSpecialColumn(z, &nKey, &zVal) ){
113952 if( nKey==9 && 0==sqlite3_strnicmp(z, "matchinfo", 9) ){
113959 }else if( nKey==8 && 0==sqlite3_strnicmp(z, "compress", 8) ){
113962 }else if( nKey==10 && 0==sqlite3_strnicmp(z, "uncompress", 10) ){
117601 int nKey = pKey->n;
117606 assert( nKey==4 );
117609 for(nKey=5; zInput[nKey]>='0' && zInput[nKey]<='9'; nKey++){
117610 nNear = nNear * 10 + (zInput[nKey] - '0');
117619 cNext = zInput[nKey];
117630 *pnConsumed = (int)((zInput - z) + nKey);
118267 static int fts3StrHash(const void *pKey, int nKey){
118270 if( nKey<=0 ) nKey = (int) strlen(z);
118271 while( nKey > 0 ){
118273 nKey--;
118285 static int fts3BinHash(const void *pKey, int nKey){
118288 while( nKey-- > 0 ){
118379 int h = (*xHash)(elem->pKey, elem->nKey) & (new_size-1);
118393 int nKey,
118406 if( (*xCompare)(elem->pKey,elem->nKey,pKey,nKey)==0 ){
118455 int nKey
118463 h = (*xHash)(pKey,nKey);
118465 return fts3FindElementByHash(pH,pKey,nKey, h & (pH->htsize-1));
118470 ** that matches pKey,nKey. Return the data for this element if it is
118473 SQLITE_PRIVATE void *sqlite3Fts3HashFind(const Fts3Hash *pH, const void *pKey, int nKey){
118476 pElem = sqlite3Fts3HashFindElem(pH, pKey, nKey);
118480 /* Insert an element into the hash table pH. The key is pKey,nKey
118498 int nKey, /* Number of bytes in the key */
118510 hraw = (*xHash)(pKey, nKey);
118513 elem = fts3FindElementByHash(pH,pKey,nKey,h);
118534 new_elem->pKey = fts3HashMalloc( nKey );
118539 memcpy((void*)new_elem->pKey, pKey, nKey);
118543 new_elem->nKey = nKey;
121168 int nKey = fts3HashKeysize(pE);
121169 if( nTerm==0 || (nKey>=nTerm && 0==memcmp(zKey, zTerm, nTerm)) ){
