contrib/sqlite3/sqlite3.c

16899 ** Collisions are on the FuncDef.u.pHash chain.  Use the SQLITE_FUNC_HASH()
17245 ** The u.pHash field is used by the global built-ins.  The u.pDestructor
17259     FuncDef *pHash;      /* Next with a different name but the same hash */
33343   unsigned int *pHash /* Write the hash value here */
33361   if( pHash ) *pHash = h;
112127   Hash *pHash;
112130   pHash = &db->aDb[iDb].pSchema->idxHash;
112131   pIndex = sqlite3HashInsert(pHash, zIdxName, 0);
112864   Hash *pHash;
112865   pHash = &(db->aDb[1].pSchema->trigHash);
112866   sqlite3HashInsert(pHash, RETURNING_TRIGGER_NAME, 0);
112889   Hash *pHash;
112918   pHash = &(db->aDb[1].pSchema->trigHash);
112919   assert( sqlite3HashFind(pHash, RETURNING_TRIGGER_NAME)==0 || pParse->nErr );
112920   if( sqlite3HashInsert(pHash, RETURNING_TRIGGER_NAME, &pRet->retTrig)
114508   Hash *pHash;
114513   pHash = &pDb->pSchema->tblHash;
114514   for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){
114520   pHash = &pDb->pSchema->idxHash;
114521   for(pElem=sqliteHashFirst(pHash); pElem; pElem=sqliteHashNext(pElem)){
117254   for(p=sqlite3BuiltinFunctions.a[h]; p; p=p->u.pHash){
117283       aDef[i].u.pHash = sqlite3BuiltinFunctions.a[h];
120543   ** FuncDef.pHash elements at start-time.  The elements of this array
120701       for(p=sqlite3BuiltinFunctions.a[i]; p; p=p->u.pHash){
128867       for(p=sqlite3BuiltinFunctions.a[i]; p; p=p->u.pHash ){
138886     Hash *pHash = &db->aDb[iDb].pSchema->trigHash;
138889     pTrig = sqlite3HashInsert(pHash, zName, pTrig);
139201   Hash *pHash;
139204   pHash = &(db->aDb[iDb].pSchema->trigHash);
139205   pTrigger = sqlite3HashInsert(pHash, zName, 0);
170241 SQLITE_PRIVATE int sqlite3Fts3InitTokenizer(Fts3Hash *pHash, const char *,
171184   Fts3Hash *pHash = (Fts3Hash *)pAux;
171257       rc = sqlite3Fts3InitTokenizer(pHash, &z[9], &pTokenizer, pzErr);
171400     rc = sqlite3Fts3InitTokenizer(pHash, "simple", &pTokenizer, pzErr);
174013   Fts3Hash *pHash = (Fts3Hash *)p;
174014   sqlite3Fts3HashClear(pHash);
174015   sqlite3_free(pHash);
174045   Fts3Hash *pHash = 0;
174073   pHash = sqlite3_malloc(sizeof(Fts3Hash));
174074   if( !pHash ){
174077     sqlite3Fts3HashInit(pHash, FTS3_HASH_STRING, 1);
174082     if( sqlite3Fts3HashInsert(pHash, "simple", 7, (void *)pSimple)
174083      || sqlite3Fts3HashInsert(pHash, "porter", 7, (void *)pPorter)
174086      || sqlite3Fts3HashInsert(pHash, "unicode61", 10, (void *)pUnicode)
174089      || (pIcu && sqlite3Fts3HashInsert(pHash, "icu", 4, (void *)pIcu))
174098     rc = sqlite3Fts3ExprInitTestInterface(db, pHash);
174107    && SQLITE_OK==(rc = sqlite3Fts3InitHashTable(db, pHash, "fts3_tokenizer"))
174115         db, "fts3", &fts3Module, (void *)pHash, hashDestroy
174119           db, "fts4", &fts3Module, (void *)pHash, 0
174123       rc = sqlite3Fts3InitTok(db, (void *)pHash);
174131   if( pHash ){
174132     sqlite3Fts3HashClear(pHash);
174133     sqlite3_free(pHash);
177853   Fts3Hash *pHash = (Fts3Hash*)sqlite3_user_data(context);
177865   rc = sqlite3Fts3InitTokenizer(pHash, zTokenizer, &pTokenizer, &zErr);
177939 SQLITE_PRIVATE int sqlite3Fts3ExprInitTestInterface(sqlite3 *db, Fts3Hash *pHash){
177941       db, "fts3_exprtest", -1, SQLITE_UTF8, (void*)pHash, fts3ExprTest, 0, 0
177945         -1, SQLITE_UTF8, (void*)pHash, fts3ExprTestRebalance, 0, 0
179075   Fts3Hash *pHash;
179082   pHash = (Fts3Hash *)sqlite3_user_data(context);
179096       pOld = sqlite3Fts3HashInsert(pHash, (void *)zName, nName, pPtr);
179106       pPtr = sqlite3Fts3HashFind(pHash, zName, nName);
179172   Fts3Hash *pHash,                /* Tokenizer hash table */
179196   m = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash,z,(int)strlen(z)+1);
179272   Fts3Hash *pHash;
179305   pHash = (Fts3Hash *)sqlite3_user_data(context);
179306   p = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash, zName, nName+1);
179468 ** the hash table pointed to by argument pHash. The hash table must
179472 **    sqlite3Fts3HashInit(pHash, FTS3_HASH_STRING, 1);
179478 ** provide read/write access to the contents of *pHash.
179485   Fts3Hash *pHash,
179489   void *p = (void *)pHash;
179844   Fts3Hash *pHash,
179852   p = (sqlite3_tokenizer_module *)sqlite3Fts3HashFind(pHash, zName, nName+1);
179926   void *pHash,                    /* Hash table of tokenizers */
179952     rc = fts3tokQueryTokenizer((Fts3Hash*)pHash, zModule, &pMod, pzErr);
180189 SQLITE_PRIVATE int sqlite3Fts3InitTok(sqlite3 *db, Fts3Hash *pHash){
180218   rc = sqlite3_create_module(db, "fts3tokenize", &fts3tok_module, (void*)pHash);
180979   Fts3Hash *pHash,                /* Pending terms hash table to add entry to */
180986   pList = (PendingList *)fts3HashFind(pHash, zToken, nToken);
180991     if( pList==fts3HashInsert(pHash, zToken, nToken, pList) ){
180995       assert( 0==fts3HashFind(pHash, zToken, nToken) );
181127     Fts3Hash *pHash = &p->aIndex[i].hPending;
181128     for(pElem=fts3HashFirst(pHash); pElem; pElem=fts3HashNext(pElem)){
181132     fts3HashClear(pHash);
181933   Fts3Hash *pHash;
181935   pHash = &p->aIndex[iIndex].hPending;
181939     for(pE=fts3HashFirst(pHash); pE; pE=fts3HashNext(pE)){
181977     pE = fts3HashFindElem(pHash, zTerm, nTerm);
219362 static void sqlite3Fts5HashFree(Fts5Hash *pHash){
219363   if( pHash ){
219364     sqlite3Fts5HashClear(pHash);
219365     sqlite3_free(pHash->aSlot);
219366     sqlite3_free(pHash);
219373 static void sqlite3Fts5HashClear(Fts5Hash *pHash){
219375   for(i=0; i<pHash->nSlot; i++){
219378     for(pSlot=pHash->aSlot[i]; pSlot; pSlot=pNext){
219383   memset(pHash->aSlot, 0, pHash->nSlot * sizeof(Fts5HashEntry*));
219384   pHash->nEntry = 0;
219409 static int fts5HashResize(Fts5Hash *pHash){
219410   int nNew = pHash->nSlot*2;
219413   Fts5HashEntry **apOld = pHash->aSlot;
219419   for(i=0; i<pHash->nSlot; i++){
219432   pHash->nSlot = nNew;
219433   pHash->aSlot = apNew;
219438   Fts5Hash *pHash,
219446     if( pHash->eDetail==FTS5_DETAIL_NONE ){
219489   Fts5Hash *pHash,
219499   int nIncr = 0;                  /* Amount to increment (*pHash->pnByte) by */
219502   bNew = (pHash->eDetail==FTS5_DETAIL_FULL);
219505   iHash = fts5HashKey2(pHash->nSlot, (u8)bByte, (const u8*)pToken, nToken);
219506   for(p=pHash->aSlot[iHash]; p; p=p->pHashNext){
219524     if( (pHash->nEntry*2)>=pHash->nSlot ){
219525       int rc = fts5HashResize(pHash);
219527       iHash = fts5HashKey2(pHash->nSlot, (u8)bByte, (const u8*)pToken, nToken);
219538     assert( iHash==fts5HashKey(pHash->nSlot, (u8*)zKey, nToken+1) );
219542     p->pHashNext = pHash->aSlot[iHash];
219543     pHash->aSlot[iHash] = p;
219544     pHash->nEntry++;
219551     if( pHash->eDetail!=FTS5_DETAIL_NONE ){
219553       p->iCol = (pHash->eDetail==FTS5_DETAIL_FULL ? 0 : -1);
219575       for(pp=&pHash->aSlot[iHash]; *pp!=p; pp=&(*pp)->pHashNext);
219589     fts5HashAddPoslistSize(pHash, p, 0);
219594     if( pHash->eDetail!=FTS5_DETAIL_NONE ){
219596       p->iCol = (pHash->eDetail==FTS5_DETAIL_FULL ? 0 : -1);
219602     if( pHash->eDetail==FTS5_DETAIL_NONE ){
219608         if( pHash->eDetail==FTS5_DETAIL_FULL ){
219631   *pHash->pnByte += nIncr;
219688   Fts5Hash *pHash,
219703   for(iSlot=0; iSlot<pHash->nSlot; iSlot++){
219705     for(pIter=pHash->aSlot[iSlot]; pIter; pIter=pIter->pHashNext){
219725   pHash->nEntry = 0;
219735   Fts5Hash *pHash,                /* Hash table to query */
219741   unsigned int iHash = fts5HashKey(pHash->nSlot, (const u8*)pTerm, nTerm);
219745   for(p=pHash->aSlot[iHash]; p; p=p->pHashNext){
219758       nList += fts5HashAddPoslistSize(pHash, p, pFaux);
219789   Fts5Hash *pHash,
219795   if( (p = pHash->pScan) ){
219798     fts5HashAddPoslistSize(pHash, p, 0);
220094   Fts5Hash *pHash;                /* Hash table for in-memory data */
221741       sqlite3Fts5HashScanNext(p->pHash);
221742       sqlite3Fts5HashScanEntry(p->pHash, &zTerm, &pList, &nList);
221817       sqlite3Fts5HashScanNext(p->pHash);
221818       sqlite3Fts5HashScanEntry(p->pHash, &zTerm, &pList, &nList);
222265   assert( p->pHash );
222271     p->rc = sqlite3Fts5HashScanInit(p->pHash, (const char*)pTerm, nTerm);
222272     sqlite3Fts5HashScanEntry(p->pHash, (const char**)&z, &pList, &nList);
222281     p->rc = sqlite3Fts5HashQuery(p->pHash, sizeof(Fts5Data),
223208       nSeg += (p->pHash ? 1 : 0);
223226       if( p->pHash ){
223436   assert( p->pHash || p->nPendingData==0 );
223437   if( p->pHash ){
223438     sqlite3Fts5HashClear(p->pHash);
224302   Fts5Hash *pHash = p->pHash;
224334       p->rc = sqlite3Fts5HashScanInit(pHash, 0, 0);
224336     while( p->rc==SQLITE_OK && 0==sqlite3Fts5HashScanEof(pHash) ){
224342       sqlite3Fts5HashScanEntry(pHash, &zTerm, &pDoclist, &nDoclist);
224425       if( p->rc==SQLITE_OK ) sqlite3Fts5HashScanNext(pHash);
224427     sqlite3Fts5HashClear(pHash);
224458     assert( p->pHash );
225068   if( p->pHash==0 ){
225069     p->rc = sqlite3Fts5HashNew(p->pConfig, &p->pHash, &p->nPendingData);
225183     sqlite3Fts5HashFree(p->pHash);
225259       p->pHash, p->iWriteRowid, iCol, iPos, FTS5_MAIN_PREFIX, pToken, nToken
225266       rc = sqlite3Fts5HashWrite(p->pHash,