Lines Matching refs:nKey
4916 const void *pKey, int nKey /* The key */
4929 const void *pKey, int nKey /* The new key */
7616 const char *pKey; int nKey; /* Key associated with this element */
7623 SQLITE_PRIVATE void *sqlite3HashInsert(Hash*, const char *pKey, int nKey, void *pData);
7624 SQLITE_PRIVATE void *sqlite3HashFind(const Hash*, const char *pKey, int nKey);
7643 /* #define sqliteHashKeysize(E) ((E)->nKey) // NOT USED */
8332 SQLITE_PRIVATE int sqlite3BtreeInsert(BtCursor*, const void *pKey, i64 nKey,
22287 static unsigned int strHash(const char *z, int nKey){
22289 assert( nKey>=0 );
22290 while( nKey > 0 ){
22292 nKey--;
22360 unsigned int h = strHash(elem->pKey, elem->nKey) % new_size;
22374 int nKey, /* Bytes in key (not counting zero terminator) */
22389 if( elem->nKey==nKey && sqlite3StrNICmp(elem->pKey,pKey,nKey)==0 ){
22432 ** that matches pKey,nKey. Return the data for this element if it is
22435 SQLITE_PRIVATE void *sqlite3HashFind(const Hash *pH, const char *pKey, int nKey){
22441 assert( nKey>=0 );
22443 h = strHash(pKey, nKey) % pH->htsize;
22447 elem = findElementGivenHash(pH, pKey, nKey, h);
22451 /* Insert an element into the hash table pH. The key is pKey,nKey
22465 SQLITE_PRIVATE void *sqlite3HashInsert(Hash *pH, const char *pKey, int nKey, void *data){
22472 assert( nKey>=0 );
22474 h = strHash(pKey, nKey) % pH->htsize;
22478 elem = findElementGivenHash(pH,pKey,nKey,h);
22486 assert(nKey==elem->nKey);
22494 new_elem->nKey = nKey;
22500 h = strHash(pKey, nKey) % pH->htsize;
48894 i64 nKey; /* The key for INTKEY tables, or number of bytes in key */
48940 i64 nKey; /* Size of pKey, or last integer key */
48945 u8 validNKey; /* True if info.nKey is valid */
48969 ** in variables BtCursor.pKey and BtCursor.nKey. When a cursor is in
49839 if( p->isIncrblobHandle && (isClearTable || p->info.nKey==iRow) ){
49924 ** Save the current cursor position in the variables BtCursor.nKey
49937 rc = sqlite3BtreeKeySize(pCur, &pCur->nKey);
49941 ** stores the integer key in pCur->nKey. In this case this value is
49943 ** table, then malloc space for and store the pCur->nKey bytes of key
49947 void *pKey = sqlite3Malloc( (int)pCur->nKey );
49949 rc = sqlite3BtreeKey(pCur, 0, (int)pCur->nKey, pKey);
50014 i64 nKey, /* Integer key for tables. Size of pKey for indices */
50024 assert( nKey==(i64)(int)nKey );
50029 sqlite3VdbeRecordUnpack(pCur->pKeyInfo, (int)nKey, pKey, pIdxKey);
50033 rc = sqlite3BtreeMovetoUnpacked(pCur, pIdxKey, nKey, bias, pRes);
50055 rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &pCur->skipNext);
50277 n += getVarint(&pCell[n], (u64*)&pInfo->nKey);
50282 pInfo->nKey = nPayload;
50411 assert( (info.nData+(pPage->intKey?0:info.nKey))==info.nPayload );
51783 ** 9-byte nKey value
53047 *pSize = pCur->info.nKey;
53217 u32 nKey;
53229 nKey = (pPage->intKey ? 0 : (int)pCur->info.nKey);
53231 if( NEVER(offset+amt > nKey+pCur->info.nData)
53449 u32 nKey;
53464 nKey = 0;
53466 nKey = (int)pCur->info.nKey;
53469 aPayload += nKey;
53470 nLocal = pCur->info.nLocal - nKey;
53473 assert( nLocal<=nKey );
53858 if( pCur->info.nKey==intKey ){
53862 if( pCur->atLast && pCur->info.nKey<intKey ){
53924 pCur->info.nKey = nCellKey;
53959 nCell = (int)pCur->info.nKey;
54680 const void *pKey, i64 nKey, /* The key */
54715 nHeader += putVarint(&pCell[nHeader], *(u64*)&nKey);
54718 assert( info.nKey==nKey );
54728 if( NEVER(nKey>0x7fffffff || pKey==0) ){
54731 nPayload += (int)nKey;
54733 nSrc = (int)nKey;
55724 sz = 4 + putVarint(&pCell[4], info.nKey);
56100 ** Insert a new record into the BTree. The key is given by (pKey,nKey)
56105 ** For an INTKEY table, only the nKey value of the key is used. pKey is
56109 ** MovetoUnpacked() to seek cursor pCur to (pKey, nKey) has already
56111 ** number if pCur points at an entry that is smaller than (pKey, nKey), or
56113 ** (pKey, nKey)).
56123 const void *pKey, i64 nKey, /* The key of the new record */
56160 invalidateIncrblobCursors(p, nKey, 0);
56177 rc = btreeMoveto(pCur, pKey, nKey, appendBias, &loc);
56183 assert( pPage->intKey || nKey>=0 );
56186 TRACE(("INSERT: table=%d nkey=%lld ndata=%d page=%d %s\n",
56187 pCur->pgnoRoot, nKey, nData, pPage->pgno,
56193 rc = fillInCell(pPage, newCell, pKey, nKey, pData, nData, nZero, &szNew);
56289 invalidateIncrblobCursors(p, pCur->info.nKey, 0);
57121 if( !pPage->intKey ) sz += (int)info.nKey;
57124 else if( i==0 ) nMinKey = nMaxKey = info.nKey;
57126 if( info.nKey <= nMaxKey ){
57128 "Rowid %lld out of order (previous was %lld)", info.nKey, nMaxKey);
57130 nMaxKey = info.nKey;
62396 ** Given the nKey-byte encoding of a record in pKey[], populate the
62402 int nKey, /* Size of the binary record */
62418 while( idx<szHdr && u<p->nField && d<=nKey ){
65267 int nKey;
69424 int nKey;
69442 u.br.nKey = pIn2->n;
69444 rc = sqlite3BtreeInsert(u.br.pCrsr, u.br.zKey, u.br.nKey, "", 0, 0, pOp->p3,
71755 ** variables nKey/aKey. If the iterator is at EOF, pFile==0.
71761 int nKey; /* Number of bytes in key */
71840 pIter->nKey = nRec;
72013 pCsr, 0, p1->aKey, p1->nKey, p2->aKey, p2->nKey, &res
72405 nToWrite = pIter->nKey + sqlite3VarintLen(pIter->nKey);
72475 *pnKey = pIter->nKey;
72489 void *pKey; int nKey; /* Sorter key to copy into pOut */
72491 pKey = vdbeSorterRowkey(pSorter, &nKey);
72492 if( sqlite3VdbeMemGrow(pOut, nKey, 0) ){
72495 pOut->n = nKey;
72497 memcpy(pOut->z, pKey, nKey);
72518 void *pKey; int nKey; /* Sorter key to compare pVal with */
72520 pKey = vdbeSorterRowkey(pSorter, &nKey);
72521 vdbeSorterCompare(pCsr, 1, pVal->z, pVal->n, pKey, nKey, pRes);
80559 int nKey;
80571 nKey = sqlite3_value_bytes(argv[2]);
80573 rc = sqlite3CodecAttach(db, db->nDb-1, zKey, nKey);
80578 sqlite3CodecGetKey(db, 0, (void**)&zKey, &nKey);
80579 if( nKey>0 || sqlite3BtreeGetReserve(db->aDb[0].pBt)>0 ){
80580 rc = sqlite3CodecAttach(db, db->nDb-1, zKey, nKey);
101286 int nKey;
101288 sqlite3CodecGetKey(db, 0, (void**)&zKey, &nKey);
101289 if( nKey ) db->nextPagesize = 0;
116373 void *pKey; int nKey; /* Key associated with this element */
116379 ** FTS3_HASH_STRING pKey points to a string that is nKey bytes long
116383 ** FTS3_HASH_BINARY pKey points to binary data nKey bytes long.
116395 SQLITE_PRIVATE void *sqlite3Fts3HashInsert(Fts3Hash*, const void *pKey, int nKey, void *pData);
116396 SQLITE_PRIVATE void *sqlite3Fts3HashFind(const Fts3Hash*, const void *pKey, int nKey);
116425 #define fts3HashKeysize(E) ((E)->nKey)
117735 int nKey;
117748 else if( isFts4 && fts3IsSpecialColumn(z, &nKey, &zVal) ){
117768 if( nKey==pOp->nOpt && !sqlite3_strnicmp(z, pOp->zOpt, pOp->nOpt) ){
122721 int nKey = pKey->n;
122726 assert( nKey==4 );
122729 for(nKey=5; zInput[nKey]>='0' && zInput[nKey]<='9'; nKey++){
122730 nNear = nNear * 10 + (zInput[nKey] - '0');
122739 cNext = zInput[nKey];
122750 *pnConsumed = (int)((zInput - z) + nKey);
123397 static int fts3StrHash(const void *pKey, int nKey){
123400 if( nKey<=0 ) nKey = (int) strlen(z);
123401 while( nKey > 0 ){
123403 nKey--;
123415 static int fts3BinHash(const void *pKey, int nKey){
123418 while( nKey-- > 0 ){
123509 int h = (*xHash)(elem->pKey, elem->nKey) & (new_size-1);
123523 int nKey,
123536 if( (*xCompare)(elem->pKey,elem->nKey,pKey,nKey)==0 ){
123585 int nKey
123593 h = (*xHash)(pKey,nKey);
123595 return fts3FindElementByHash(pH,pKey,nKey, h & (pH->htsize-1));
123600 ** that matches pKey,nKey. Return the data for this element if it is
123603 SQLITE_PRIVATE void *sqlite3Fts3HashFind(const Fts3Hash *pH, const void *pKey, int nKey){
123606 pElem = sqlite3Fts3HashFindElem(pH, pKey, nKey);
123610 /* Insert an element into the hash table pH. The key is pKey,nKey
123628 int nKey, /* Number of bytes in the key */
123640 hraw = (*xHash)(pKey, nKey);
123643 elem = fts3FindElementByHash(pH,pKey,nKey,h);
123664 new_elem->pKey = fts3HashMalloc( nKey );
123669 memcpy((void*)new_elem->pKey, pKey, nKey);
123673 new_elem->nKey = nKey;
126628 int nKey = fts3HashKeysize(pE);
126629 if( nTerm==0 || (nKey>=nTerm && 0==memcmp(zKey, zTerm, nTerm)) ){
