Lines Matching defs:pKey
6462 const void *pKey, int nKey /* The key */
6467 const void *pKey, int nKey /* The key */
6480 const void *pKey, int nKey /* The new key */
6485 const void *pKey, int nKey /* The new key */
13949 const char *pKey; /* Key associated with this element */
13956 SQLITE_PRIVATE void *sqlite3HashInsert(Hash*, const char *pKey, void *pData);
13957 SQLITE_PRIVATE void *sqlite3HashFind(const Hash*, const char *pKey);
13975 /* #define sqliteHashKey(E) ((E)->pKey) // NOT USED */
15697 ** an arbitrary key and no data. These btrees have pKey,nKey set to the
15703 ** the key and passed in the nKey field. The pKey field is zero.
15712 ** pKey always NULL encoded key
15713 ** nKey the ROWID length of pKey
15727 const void *pKey; /* Key content for indexes. NULL for tables */
15728 sqlite3_int64 nKey; /* Size of pKey for indexes. PRIMARY KEY for tabs */
15730 sqlite3_value *aMem; /* First of nMem value in the unpacked pKey */
35452 unsigned int h = strHash(elem->pKey) % new_size;
35466 const char *pKey, /* The key we are searching for */
35476 h = strHash(pKey) % pH->htsize;
35488 if( sqlite3StrICmp(elem->pKey,pKey)==0 ){
35531 ** that matches pKey. Return the data for this element if it is
35534 SQLITE_PRIVATE void *sqlite3HashFind(const Hash *pH, const char *pKey){
35536 assert( pKey!=0 );
35537 return findElementWithHash(pH, pKey, 0)->data;
35540 /* Insert an element into the hash table pH. The key is pKey
35554 SQLITE_PRIVATE void *sqlite3HashInsert(Hash *pH, const char *pKey, void *data){
35560 assert( pKey!=0 );
35561 elem = findElementWithHash(pH,pKey,&h);
35568 elem->pKey = pKey;
35575 new_elem->pKey = pKey;
35581 h = strHash(pKey) % pH->htsize;
68100 void *pKey; /* Saved key that was cursor last known position */
68108 i64 nKey; /* Size of pKey, or last integer key */
68149 ** in variables BtCursor.pKey and BtCursor.nKey. When a cursor is in
69275 ** pCur->pKey. SQLITE_OK is returned if successful or an SQLite error
69279 ** (the rowid) is stored in pCur->nKey and pCur->pKey is left set to
69280 ** NULL. If the cursor is open on a non-intkey table, then pCur->pKey is
69287 assert( 0==pCur->pKey );
69300 void *pKey;
69302 pKey = sqlite3Malloc( pCur->nKey + 9 + 8 );
69303 if( pKey ){
69304 rc = sqlite3BtreePayload(pCur, 0, (int)pCur->nKey, pKey);
69306 memset(((u8*)pKey)+pCur->nKey, 0, 9+8);
69307 pCur->pKey = pKey;
69309 sqlite3_free(pKey);
69315 assert( !pCur->curIntKey || !pCur->pKey );
69321 ** and BtCursor.pKey. The cursor's state is set to CURSOR_REQUIRESEEK.
69330 assert( 0==pCur->pKey );
69420 sqlite3_free(pCur->pKey);
69421 pCur->pKey = 0;
69426 ** In this version of BtreeMoveto, pKey is a packed index record
69432 const void *pKey, /* Packed key if the btree is an index */
69433 i64 nKey, /* Integer key for tables. Size of pKey for indices */
69440 if( pKey ){
69445 sqlite3VdbeRecordUnpack(pKeyInfo, (int)nKey, pKey, pIdxKey);
69478 rc = btreeMoveto(pCur, pCur->pKey, pCur->nKey, 0, &skipNext);
69481 sqlite3_free(pCur->pKey);
69482 pCur->pKey = 0;
73304 sqlite3_free(pCur->pKey);
75473 assert( pX->nKey<=0x7fffffff && pX->pKey!=0 );
75475 pSrc = pX->pKey;
77605 ** the key is used. The pX.pKey value must be NULL. The pX.nKey is the
77610 ** key is an arbitrary byte sequence stored in pX.pKey,nKey. The
77614 ** sqlite3BtreeIndexMoveto() to seek cursor pCur to (pKey,nKey) has already
77618 ** smaller then (pKey,nKey). If seekResult>0 then pCur points to a cell
77619 ** that is larger than (pKey,nKey).
77623 ** point for (pKey,nKey) before doing the insertion. For index btrees,
77625 ** key values and pX->aMem can be used instead of pX->pKey to avoid having
77692 assert( (flags & BTREE_PREFORMAT) || (pX->pKey==0)==(pCur->pKeyInfo==0) );
77695 assert( pX->pKey==0 );
77760 rc = btreeMoveto(pCur, pX->pKey, pX->nKey,
77774 x2.pData = pX->pKey;
77909 assert( pCur->pKey==0 );
77910 pCur->pKey = sqlite3Malloc( pX->nKey );
77911 if( pCur->pKey==0 ){
77914 memcpy(pCur->pKey, pX->pKey, pX->nKey);
86592 ** Given the nKey-byte encoding of a record in pKey[], populate the
86599 const void *pKey, /* The binary record */
86602 const unsigned char *aKey = (const unsigned char *)pKey;
86754 ** pKey,nKey. The verify that this count is less than or equal to the
86764 int nKey, const void *pKey, /* The record to verify */
86771 const unsigned char *aKey = (const unsigned char*)pKey;
89808 ** record in nKey/pKey. Return a pointer to the new UnpackedRecord structure
89814 const void *pKey
89821 sqlite3VdbeRecordUnpack(pKeyInfo, nKey, pKey, pRet);
95899 Mem *pKey; /* MEM cell holding key for the record */
95919 pKey = &aMem[pOp->p3];
95920 assert( pKey->flags & MEM_Int );
95921 assert( memIsValid(pKey) );
95922 REGISTER_TRACE(pOp->p3, pKey);
95923 x.nKey = pKey->u.i;
95960 x.pKey = 0;
96683 x.pKey = pIn2->z;
102452 void *pKey;
102464 pKey = pReader->aKey;
102467 pKey = SRVAL(pSorter->list.pList);
102469 return pKey;
102477 void *pKey; int nKey; /* Sorter key to copy into pOut */
102481 pKey = vdbeSorterRowkey(pSorter, &nKey);
102487 memcpy(pOut->z, pKey, nKey);
102518 void *pKey; int nKey; /* Sorter key to compare pVal with */
102531 pKey = vdbeSorterRowkey(pSorter, &nKey);
102532 sqlite3VdbeRecordUnpack(pKeyInfo, nKey, pKey, r2);
116917 Expr *pKey /* Database key for encryption extension */
116932 SQLITE_OK!=resolveAttachExpr(&sName, pKey)
116958 sqlite3ExprCode(pParse, pKey, regArgs+2);
116974 sqlite3ExprDelete(db, pKey);
117000 ** ATTACH p AS pDbname KEY pKey
117002 SQLITE_PRIVATE void sqlite3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *pKey){
117014 codeAttach(pParse, SQLITE_ATTACH, &attach_func, p, p, pDbname, pKey);
121216 KeyInfo *pKey; /* KeyInfo for index */
121238 pKey = sqlite3KeyInfoOfIndex(pParse, pIndex);
121239 assert( pKey!=0 || pParse->nErr );
121244 sqlite3KeyInfoRef(pKey), P4_KEYINFO);
121260 (char *)pKey, P4_KEYINFO);
123005 KeyInfo *pKey;
123008 pKey = sqlite3KeyInfoAlloc(pParse->db, nKey, nCol-nKey);
123010 pKey = sqlite3KeyInfoAlloc(pParse->db, nCol, 0);
123012 if( pKey ){
123013 assert( sqlite3KeyInfoIsWriteable(pKey) );
123016 pKey->aColl[i] = zColl==sqlite3StrBINARY ? 0 :
123018 pKey->aSortFlags[i] = pIdx->aSortOrder[i];
123019 assert( 0==(pKey->aSortFlags[i] & KEYINFO_ORDER_BIGNULL) );
123034 sqlite3KeyInfoUnref(pKey);
123035 pKey = 0;
123038 return pKey;
179259 void *pKey; int nKey; /* Key associated with this element */
179265 ** FTS3_HASH_STRING pKey points to a string that is nKey bytes long
179269 ** FTS3_HASH_BINARY pKey points to binary data nKey bytes long.
179281 SQLITE_PRIVATE void *sqlite3Fts3HashInsert(Fts3Hash*, const void *pKey, int nKey, void *pData);
179282 SQLITE_PRIVATE void *sqlite3Fts3HashFind(const Fts3Hash*, const void *pKey, int nKey);
179310 #define fts3HashKey(E) ((E)->pKey)
186753 const struct Fts3Keyword *pKey = &aKeyword[ii];
186755 if( (pKey->parenOnly & ~sqlite3_fts3_enable_parentheses)!=0 ){
186759 if( nInput>=pKey->n && 0==memcmp(zInput, pKey->z, pKey->n) ){
186761 int nKey = pKey->n;
186765 if( pKey->eType==FTSQUERY_NEAR ){
186784 pRet->eType = pKey->eType;
187700 if( pH->copyKey && elem->pKey ){
187701 fts3HashFree(elem->pKey);
187712 static int fts3StrHash(const void *pKey, int nKey){
187713 const char *z = (const char *)pKey;
187730 static int fts3BinHash(const void *pKey, int nKey){
187732 const char *z = (const char *)pKey;
187824 int h = (*xHash)(elem->pKey, elem->nKey) & (new_size-1);
187837 const void *pKey, /* The key we are searching for */
187851 if( (*xCompare)(elem->pKey,elem->nKey,pKey,nKey)==0 ){
187885 if( pH->copyKey && elem->pKey ){
187886 fts3HashFree(elem->pKey);
187899 const void *pKey,
187908 h = (*xHash)(pKey,nKey);
187910 return fts3FindElementByHash(pH,pKey,nKey, h & (pH->htsize-1));
187915 ** that matches pKey,nKey. Return the data for this element if it is
187918 SQLITE_PRIVATE void *sqlite3Fts3HashFind(const Fts3Hash *pH, const void *pKey, int nKey){
187921 pElem = sqlite3Fts3HashFindElem(pH, pKey, nKey);
187925 /* Insert an element into the hash table pH. The key is pKey,nKey
187942 const void *pKey, /* The key */
187955 hraw = (*xHash)(pKey, nKey);
187958 elem = fts3FindElementByHash(pH,pKey,nKey,h);
187978 if( pH->copyKey && pKey!=0 ){
187979 new_elem->pKey = fts3HashMalloc( nKey );
187980 if( new_elem->pKey==0 ){
187984 memcpy((void*)new_elem->pKey, pKey, nKey);
187986 new_elem->pKey = (void*)pKey;
245713 int sqlite3CodecAttach(sqlite3* db, int nDb, const void *pKey, int nKey){
245718 if(p == NULL || pKey == NULL || nKey <= 0){
245733 int rc = sqlite3CodecInitContext(ctx, p, pKey, nKey, nDb);
245735 int rc = sqlite3CodecInitContext(ctx, p, pKey, nKey);
245756 void sqlite3CodecGetKey(sqlite3* db, int nDb, void **pKey, int *nKey)
245765 *pKey = ctx->readCtx->password;
245768 *pKey = ctx->readCtx->keyInfo;
245772 *pKey = NULL;
245778 int sqlite3_key(sqlite3 *db, const void *pKey, int nKey){
245779 return sqlite3_key_v2(db, "main", pKey, nKey);
245782 int sqlite3_key_v2(sqlite3 *db, const char *zDb, const void *pKey, int nKey){
245783 if(db == NULL || pKey == NULL || nKey <= 0){
245787 return sqlite3CodecAttach(db, iDb, pKey, nKey);
245790 int sqlite3_rekey(sqlite3 *db, const void *pKey, int nKey){
245791 return sqlite3_rekey_v2(db, "main", pKey, nKey);
245794 int sqlite3_rekey_v2(sqlite3 *db, const char *zDb, const void *pKey, int nKey){
245795 if(db == NULL || pKey == NULL || nKey == 0){
245813 int rc = sqlite3CodecSetPassword(ctx->writeCtx, pKey, nKey);