Lines Matching defs:reader
10535 ** by the reader until a new read transaction is started.
15060 ** which means we can use reader/writer locks. When reader/writer locks
15064 ** But a single Win95 reader will lock out all WinNT readers and a single
15065 ** WinNT reader will lock out all other Win95 readers.
39035 ** (1) There is zero concurrency. A single reader blocks all other
45324 int nReaders; /* Number of reader locks obtained */
47534 /* Releasing a reader lock or an exclusive lock */
47544 /* Did we just have a reader lock? */
48230 ** Acquire a reader lock.
58753 ** that snapshot for use by the reader in spite of concurrently changes by
63463 ** To read a page from the database (call it page number P), a reader
63471 ** To start a read transaction, the reader records the index of the last
63472 ** valid frame in the WAL. The reader uses this recorded "mxFrame" value
63474 ** to the WAL, but as long as the reader uses its original mxFrame value
63480 ** The reader algorithm in the previous paragraphs works correctly, but
63482 ** reader has to scan the entire WAL looking for page P frames. If the
63595 ** reader might be using some value K0 and a second reader that started
63600 ** K>K0 but to the first reader, those entries will appear to be unused
63601 ** slots in the hash table and so the first reader will get an answer as
63603 ** in the first place - which is what reader one wants. Meanwhile, the
63604 ** second reader using K1 will see additional values that were inserted
63605 ** later, which is exactly what reader two wants.
63643 ** of available reader locks and should be at least 3. The default
63719 ** There is one entry in aReadMark[] for each reader lock. If a reader
63721 ** the mxFrame for that reader. The value READMARK_NOT_USED (0xffffffff)
63730 ** aReadMark[K] cannot changed while there is a reader is using that mark
63731 ** since the reader will be holding a shared lock on WAL_READ_LOCK(K).
63741 ** will choose aReadMark[0] which has value 0 and hence such reader will
64724 ** cause a concurrent reader to malfunction. Memcpy() is allowed to
65373 ** that a concurrent reader might be using.
65529 /* Release the reader lock held while backfilling */
65562 ** wal-index header in shared memory, as all subsequent reader or
66057 ** that means the Wal does not hold any read lock. The reader must not
66059 ** including frame number aReadMark[pWal->readLock]. The reader will
66061 ** Or if pWal->readLock==0, then the reader will ignore the WAL
66172 /* It is not safe to allow the reader to continue here if frames
66174 ** When holding READ_LOCK(0), the reader ignores the entire log file,
66195 /* If we get this far, it means that the reader will want to use
66510 u32 iLast = pWal->hdr.mxFrame; /* Last page in WAL for this reader */
66520 ** then the WAL is ignored by the reader so return early, as if the
97009 ** This opcode throws an error if there are any active reader VMs when
101935 ** incremental-reader (pReadr->pIncr!=0). This function serves to open
102044 ** If the PmaReader passed as the first argument is not an incremental-reader
116055 ** Used to pass information from the analyzer reader through to the
179689 Fts3MultiSegReader *pSegcsr; /* Segment-reader for this token */
182601 ** Add seg-reader objects to the Fts3MultiSegReader object passed as the
182622 /* If iLevel is less than 0 and this is not a scan, include a seg-reader
182743 Fts3MultiSegReader **ppSegcsr /* OUT: Allocated seg-reader cursor */
182812 Fts3MultiSegReader *pSegcsr; /* Seg-reader cursor for this term */
190027 u8 rootOnly; /* True for a root-only reader */
191373 /* A pending-terms seg-reader for an FTS4 table that uses order=desc.
191754 Fts3SegReader *pSeg, /* Segment reader object */
192415 ** opened with seg-reader pSeg. This function does not affect the contents
192553 Fts3MultiSegReader *pMsr, /* Multi-segment-reader handle */
192572 Fts3MultiSegReader *pMsr, /* Multi-segment-reader handle */
193653 ** Attempt to advance the node-reader object passed as the first argument to
193703 ** Release all dynamic resources held by node-reader object *p.
193710 ** Initialize a node-reader object to read the node in buffer aNode/nNode.
194186 NodeReader reader;
194187 for(rc = nodeReaderInit(&reader, aLeaf, nLeaf);
194188 rc==SQLITE_OK && reader.aNode;
194189 rc = nodeReaderNext(&reader)
194191 assert( reader.aNode );
194193 if( fts3TermCmp(zKey, nKey, reader.term.a, reader.term.n)<=0 ){
194196 nodeReaderRelease(&reader);
194234 NodeReader reader;
194238 rc = nodeReaderInit(&reader, pNode->block.a, pNode->block.n);
194239 while( reader.aNode && rc==SQLITE_OK ) rc = nodeReaderNext(&reader);
194240 blobGrowBuffer(&pNode->key, reader.term.n, &rc);
194242 assert_fts3_nc( reader.term.n>0 || reader.aNode==0 );
194243 if( reader.term.n>0 ){
194244 memcpy(pNode->key.a, reader.term.a, reader.term.n);
194246 pNode->key.n = reader.term.n;
194251 pNode->iBlock = reader.iChild;
194252 rc = sqlite3Fts3ReadBlock(p, reader.iChild, &aBlock, &nBlock,0);
194265 nodeReaderRelease(&reader);
194502 NodeReader reader; /* Reader object */
194516 for(rc = nodeReaderInit(&reader, aNode, nNode);
194517 rc==SQLITE_OK && reader.aNode;
194518 rc = nodeReaderNext(&reader)
194521 int res = fts3TermCmp(reader.term.a, reader.term.n, zTerm, nTerm);
194523 fts3StartNode(pNew, (int)aNode[0], reader.iChild);
194524 *piBlock = reader.iChild;
194527 pNew, &prev, reader.term.a, reader.term.n,
194528 reader.aDoclist, reader.nDoclist
194533 fts3StartNode(pNew, (int)aNode[0], reader.iChild);
194534 *piBlock = reader.iChild;
194538 nodeReaderRelease(&reader);
194661 /* Seg-reader is at EOF. Remove the entire input segment. */
208742 ** non-RBU reader clients may see the original database.
222370 ** Close the reader blob handle, if it is open.
227028 Fts5LookaheadReader reader; /* Input iterator */
227075 ** buffer and buffer size to the lookaside-reader init function, zero
227084 fts5LookaheadReaderInit(pPoslist->p, pPoslist->n, &a[i].reader);
227096 iMax = a[0].reader.iPos;
227100 Fts5LookaheadReader *pPos = &a[i].reader;
227114 i64 iPos = a[i].reader.iPos;
227122 iMin = a[0].reader.iLookahead;
227124 if( a[i].reader.iLookahead < iMin ){
227125 iMin = a[i].reader.iLookahead;
227129 if( fts5LookaheadReaderNext(&a[iAdv].reader) ) goto ismatch_out;