Lines Matching defs: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;
48922 i64 nKey; /* The key for INTKEY tables, or number of bytes in key */
48968 i64 nKey; /* Size of pKey, or last integer key */
48973 u8 validNKey; /* True if info.nKey is valid */
48997 ** in variables BtCursor.pKey and BtCursor.nKey. When a cursor is in
49867 if( p->isIncrblobHandle && (isClearTable || p->info.nKey==iRow) ){
49952 ** Save the current cursor position in the variables BtCursor.nKey
49965 rc = sqlite3BtreeKeySize(pCur, &pCur->nKey);
49969 ** stores the integer key in pCur->nKey. In this case this value is
49971 ** table, then malloc space for and store the pCur->nKey bytes of key
49975 void *pKey = sqlite3Malloc( (int)pCur->nKey );
49977 rc = sqlite3BtreeKey(pCur, 0, (int)pCur->nKey, pKey);
50042 i64 nKey, /* Integer key for tables. Size of pKey for indices */
50052 assert( nKey==(i64)(int)nKey );
50057 sqlite3VdbeRecordUnpack(pCur->pKeyInfo, (int)nKey, pKey, pIdxKey);
50061 rc = sqlite3BtreeMovetoUnpacked(pCur, pIdxKey, nKey, bias, pRes);
50083 rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &pCur->skipNext);
50305 n += getVarint(&pCell[n], (u64*)&pInfo->nKey);
50310 pInfo->nKey = nPayload;
50439 assert( (info.nData+(pPage->intKey?0:info.nKey))==info.nPayload );
51811 ** 9-byte nKey value
53075 *pSize = pCur->info.nKey;
53245 u32 nKey;
53257 nKey = (pPage->intKey ? 0 : (int)pCur->info.nKey);
53259 if( NEVER(offset+amt > nKey+pCur->info.nData)
53477 u32 nKey;
53492 nKey = 0;
53494 nKey = (int)pCur->info.nKey;
53497 aPayload += nKey;
53498 nLocal = pCur->info.nLocal - nKey;
53501 assert( nLocal<=nKey );
53886 if( pCur->info.nKey==intKey ){
53890 if( pCur->atLast && pCur->info.nKey<intKey ){
53952 pCur->info.nKey = nCellKey;
53987 nCell = (int)pCur->info.nKey;
54708 const void *pKey, i64 nKey, /* The key */
54743 nHeader += putVarint(&pCell[nHeader], *(u64*)&nKey);
54746 assert( info.nKey==nKey );
54756 if( NEVER(nKey>0x7fffffff || pKey==0) ){
54759 nPayload += (int)nKey;
54761 nSrc = (int)nKey;
55752 sz = 4 + putVarint(&pCell[4], info.nKey);
56128 ** Insert a new record into the BTree. The key is given by (pKey,nKey)
56133 ** For an INTKEY table, only the nKey value of the key is used. pKey is
56137 ** MovetoUnpacked() to seek cursor pCur to (pKey, nKey) has already
56139 ** number if pCur points at an entry that is smaller than (pKey, nKey), or
56141 ** (pKey, nKey)).
56151 const void *pKey, i64 nKey, /* The key of the new record */
56188 invalidateIncrblobCursors(p, nKey, 0);
56205 rc = btreeMoveto(pCur, pKey, nKey, appendBias, &loc);
56211 assert( pPage->intKey || nKey>=0 );
56214 TRACE(("INSERT: table=%d nkey=%lld ndata=%d page=%d %s\n",
56215 pCur->pgnoRoot, nKey, nData, pPage->pgno,
56221 rc = fillInCell(pPage, newCell, pKey, nKey, pData, nData, nZero, &szNew);
56317 invalidateIncrblobCursors(p, pCur->info.nKey, 0);
57149 if( !pPage->intKey ) sz += (int)info.nKey;
57152 else if( i==0 ) nMinKey = nMaxKey = info.nKey;
57154 if( info.nKey <= nMaxKey ){
57156 "Rowid %lld out of order (previous was %lld)", info.nKey, nMaxKey);
57158 nMaxKey = info.nKey;
62424 ** Given the nKey-byte encoding of a record in pKey[], populate the
62430 int nKey, /* Size of the binary record */
62446 while( idx<szHdr && u<p->nField && d<=nKey ){
65295 int nKey;
69452 int nKey;
69470 u.br.nKey = pIn2->n;
69472 rc = sqlite3BtreeInsert(u.br.pCrsr, u.br.zKey, u.br.nKey, "", 0, 0, pOp->p3,
71783 ** variables nKey/aKey. If the iterator is at EOF, pFile==0.
71789 int nKey; /* Number of bytes in key */
71868 pIter->nKey = nRec;
72041 pCsr, 0, p1->aKey, p1->nKey, p2->aKey, p2->nKey, &res
72433 nToWrite = pIter->nKey + sqlite3VarintLen(pIter->nKey);
72503 *pnKey = pIter->nKey;
72517 void *pKey; int nKey; /* Sorter key to copy into pOut */
72519 pKey = vdbeSorterRowkey(pSorter, &nKey);
72520 if( sqlite3VdbeMemGrow(pOut, nKey, 0) ){
72523 pOut->n = nKey;
72525 memcpy(pOut->z, pKey, nKey);
72546 void *pKey; int nKey; /* Sorter key to compare pVal with */
72548 pKey = vdbeSorterRowkey(pSorter, &nKey);
72549 vdbeSorterCompare(pCsr, 1, pVal->z, pVal->n, pKey, nKey, pRes);
80595 int nKey;
80607 nKey = sqlite3_value_bytes(argv[2]);
80609 rc = sqlite3CodecAttach(db, db->nDb-1, zKey, nKey);
80614 sqlite3CodecGetKey(db, 0, (void**)&zKey, &nKey);
80615 if( nKey>0 || sqlite3BtreeGetReserve(db->aDb[0].pBt)>0 ){
80616 rc = sqlite3CodecAttach(db, db->nDb-1, zKey, nKey);
101322 int nKey;
101324 sqlite3CodecGetKey(db, 0, (void**)&zKey, &nKey);
101325 if( nKey ) db->nextPagesize = 0;
116409 void *pKey; int nKey; /* Key associated with this element */
116415 ** FTS3_HASH_STRING pKey points to a string that is nKey bytes long
116419 ** FTS3_HASH_BINARY pKey points to binary data nKey bytes long.
116431 SQLITE_PRIVATE void *sqlite3Fts3HashInsert(Fts3Hash*, const void *pKey, int nKey, void *pData);
116432 SQLITE_PRIVATE void *sqlite3Fts3HashFind(const Fts3Hash*, const void *pKey, int nKey);
116461 #define fts3HashKeysize(E) ((E)->nKey)
117771 int nKey;
117784 else if( isFts4 && fts3IsSpecialColumn(z, &nKey, &zVal) ){
117804 if( nKey==pOp->nOpt && !sqlite3_strnicmp(z, pOp->zOpt, pOp->nOpt) ){
122769 int nKey = pKey->n;
122774 assert( nKey==4 );
122777 for(nKey=5; zInput[nKey]>='0' && zInput[nKey]<='9'; nKey++){
122778 nNear = nNear * 10 + (zInput[nKey] - '0');
122787 cNext = zInput[nKey];
122798 *pnConsumed = (int)((zInput - z) + nKey);
123445 static int fts3StrHash(const void *pKey, int nKey){
123448 if( nKey<=0 ) nKey = (int) strlen(z);
123449 while( nKey > 0 ){
123451 nKey--;
123463 static int fts3BinHash(const void *pKey, int nKey){
123466 while( nKey-- > 0 ){
123557 int h = (*xHash)(elem->pKey, elem->nKey) & (new_size-1);
123571 int nKey,
123584 if( (*xCompare)(elem->pKey,elem->nKey,pKey,nKey)==0 ){
123633 int nKey
123641 h = (*xHash)(pKey,nKey);
123643 return fts3FindElementByHash(pH,pKey,nKey, h & (pH->htsize-1));
123648 ** that matches pKey,nKey. Return the data for this element if it is
123651 SQLITE_PRIVATE void *sqlite3Fts3HashFind(const Fts3Hash *pH, const void *pKey, int nKey){
123654 pElem = sqlite3Fts3HashFindElem(pH, pKey, nKey);
123658 /* Insert an element into the hash table pH. The key is pKey,nKey
123676 int nKey, /* Number of bytes in the key */
123688 hraw = (*xHash)(pKey, nKey);
123691 elem = fts3FindElementByHash(pH,pKey,nKey,h);
123712 new_elem->pKey = fts3HashMalloc( nKey );
123717 memcpy((void*)new_elem->pKey, pKey, nKey);
123721 new_elem->nKey = nKey;
126676 int nKey = fts3HashKeysize(pE);
126677 if( nTerm==0 || (nKey>=nTerm && 0==memcmp(zKey, zTerm, nTerm)) ){
