Lines Matching defs:block
182 ** system #includes. Hence, this block of code must be the very first
268 ** this is the only known way to reliably obtain it. This entire #if block
1402 ** be advantageous to block on the next WAL lock if the lock is not immediately
1452 ** to block for up to M milliseconds before failing when attempting to
2203 ** aligned block of memory of at least sz*N bytes, otherwise
3249 ** ^The sqlite3_malloc() routine returns a pointer to a block
3313 ** a block of memory after it has been released using
3771 ** (Mutexes will block any actual concurrency, but in this mode
8142 ** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
10847 } /* End of the 'extern "C"' block */
10964 } /* end of the 'extern "C"' block */
13264 } /* end of the 'extern "C"' block */
13728 ** where multiple cases go to the same block of code, testcase()
14900 ** After the following block of preprocess macros, all of
19006 AutoincInfo *pNext; /* Next info block in a list of them all */
19007 Table *pTab; /* Table this info block refers to */
19125 int nRangeReg; /* Size of the temporary register block */
19126 int iRangeReg; /* First register in temporary register block */
21133 ** If we compile with the SQLITE_TEST macro set, then the following block
24882 ** If we compile with the SQLITE_TEST macro set, then the following block
25328 ** sqlite3_mem_methods structure fails to allocate a block of memory
25861 ** Title text to insert in front of each block
26306 ** use of malloc(). The SQLite user supplies a block of memory
26340 ** more blocks where each block is 8 bytes. The first 8 bytes are
26344 ** free. The first block has format u.hdr. u.hdr.size4x is 4 times the
26356 ** this is done, the chunk index refers to the second block of
26361 ** The second block of free chunks is of the form u.list. The
26366 ** The second block of a chunk is user data if the chunk is checked
26423 ** Array of lists of free blocks according to the block size
26424 ** for smaller chunks, or a hash on the block size for larger
26571 /* Split the key block. Return the tail. */
26638 ** Return a block of memory of at least nBytes in size.
26848 /* Store a pointer to the memory block in global structure mem3. */
26853 /* Initialize the key block. */
26958 ** arguments specify the block of memory to manage.
26996 ** use of malloc(). The application gives SQLite a block of memory
27010 ** 2. If two adjacent free blocks are the halves of a larger block,
27011 ** then the two blocks are coalesced into the single larger block.
27013 ** 3. New memory is allocated from the first available free block.
27063 #define CTRL_LOGSIZE 0x1f /* Log2 Size of this block */
27108 ** of each block. One byte per block.
27191 ** Return a block of memory of at least nBytes in size.
27225 ** block. If not, then split a block of the next larger power of
27226 ** two in order to create a new free block of size iLogsize.
27274 /* Set iBlock to the index of the block pointed to by pOld in
27279 /* Check that the pointer pOld points to a valid, non-free block. */
27600 ** This block (enclosed by SQLITE_ENABLE_MULTITHREADED_CHECKS) contains
27736 ** Enter the mutex (do not block).
27792 ** sqlite3_initialize() being called. This block copies pointers to
27878 ** Obtain the mutex p. If some other thread already has the mutex, block
28087 ** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
28393 ** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
28915 ** sqlite3_mutex_enter() will block and sqlite3_mutex_try() will return
29739 ** Resize the block of memory pointed to by p to n bytes. If the
32655 /* The RFC-7539 ChaCha20 block function
40459 /* The following "ifdef/elif/else/" block has the same structure as
40760 ** single byte to the last byte in each block that falls entirely
40766 int nBlk = buf.st_blksize; /* File-system block size */
41084 ** Return the sector size in bytes of the underlying block device for
41254 ** Locks block if the mask is exactly UNIX_SHM_C and are non-blocking
41848 ** It is not permitted to block on the RECOVER lock.
41907 /* Make sure no sibling connections hold locks that will block this
42918 /* zPath is a path to a WAL or journal file. The following block derives
42919 ** the path to the associated database file from zPath. This block handles
46322 ** largest committed free block in the heap, in bytes.
46578 sqlite3_log(SQLITE_NOMEM, "failed to HeapFree block %p (%lu), heap=%p",
46628 sqlite3_log(SQLITE_NOMEM, "failed to HeapSize block %p (%lu), heap=%p",
46720 ** arguments specify the block of memory to manage.
48717 ** Return the sector size in bytes of the underlying block device for
49223 /* Make sure no sibling connections hold locks that will block this
51285 ** block of memory.
55509 ** This comment block describes invariants that hold when using a rollback
55513 ** Within this comment block, a page is deemed to have been synced
56131 ** The following block contains those class members that change during
56132 ** routine operation. Class members not in this block are either fixed
57030 ** even if that means explicitly writing data to the block of
57376 ** code is cleared and the cache reset in the block below.
58042 ** TODO: This function allocates a single block of memory to load
59806 /* This block deals with an obscure problem. If the last connection
61515 ** page in the block above, set the need-sync flag for the page.
61839 ** 'isDirect' below, as well as the block enclosed in the
62041 /* The following block updates the change-counter. Exactly how it
63520 ** Each index block except for the first contains information on
63521 ** HASHTABLE_NPAGE frames. The first index block contains information on
63524 ** first index block are the same size as all other index blocks in the
63530 ** Each index block contains two sections, a page-mapping that contains the
63532 ** that allows readers to query an index block for a specific page number.
63534 ** for the first index block) 32-bit page numbers. The first entry in the
63535 ** first index-block contains the database page number corresponding to the
63536 ** first frame in the WAL file. The first entry in the second index block
63540 ** The last index block in a wal-index usually contains less than the full
63547 ** can be found by scanning the page-mapping sections of each index block
63548 ** starting with the last index block and moving toward the first, and
63549 ** within each index block, starting at the end and moving toward the
63559 ** index block. Let K be the 1-based index of the largest entry in
63561 ** always be exactly HASHTABLE_NPAGE (4096) and for the last index block
63579 ** current index block. Otherwise the iMax-th mapping entry of the
63580 ** current index block corresponds to the last entry that references
63583 ** A hash search begins with the last index block and moves toward the
63584 ** first index block, looking for entries corresponding to page P. On
63585 ** average, only two or three slots in each index block need to be
63587 ** establish that no such entry exists in the block. Each index block
63829 /* A block of WALINDEX_LOCK_RESERVED bytes beginning at
63874 int szFirstBlock; /* Size of first block written to WAL file */
63963 ** The block of page numbers associated with the first hash-table in a
65168 /* Allocate temporary space used by the merge-sort routine. This block
65378 ** process, foreground threads will never block on a lengthy fsync call.
65541 ** entire wal file has been copied into the database file, then block
66543 ** loop of the following block is more stringent that would be required
68392 ** procedure that follows. Just be sure not to block.
69784 ** Parse a cell content block and fill in the CellInfo structure.
69826 /* The next block of code is equivalent to:
69842 /* The next block of code is equivalent to:
70037 ** integer. The following block moves pIter to point at the first byte
70103 ** page so that there are no free-blocks on the free-block list.
70142 /* This block handles pages with two or fewer free blocks and nMaxFrag
70406 ** The first byte of the new free block is pPage->aData[iStart]
70407 ** and the size of the block is iSize bytes.
70717 ** Initialize the auxiliary information for a disk block.
72197 ** block for the WRITER lock first if possible. */
73048 ** that are contained within a BEGIN...COMMIT block. If a constraint
74147 /* This block serves to assert() that the cursor really does point
75124 ** Normally, new pages allocated by this block can be requested from the
75253 ** first trunk page in the current free-list. This block tests if it
76783 ** Values computed by this block:
76857 ** The packing computed by the previous block is biased toward the siblings
76860 ** The next block of code attempts to adjust the packing of siblings to
80258 /* This block ensures that all data required to recreate the original
81738 /* The following block sets the new values of Mem.z and Mem.xDel. It
84560 /* This block is really an inlined version of sqlite3VdbeMemRelease()
85767 ** Note: This block also runs if one of the special errors handled
88684 ** into the database handle. This block copies the error message
92591 ** operator actually is. The next block of code depends on the fact
97901 ** might change from one evaluation to the next. The next block of code
98796 ** might change from one evaluation to the next. The next block of code
99995 ** above contains the index of the smallest of each block of 4 PmaReaders
100060 ** to block until it finishes).
100063 ** to sqlite3ThreadJoin() is likely to block. Cases that are likely to
100064 ** block provoke debugging output.
100187 ** each block is aligned on a page boundary. This object caches writes to
101916 ** in use it will block the vdbePmaReaderNext() call while it uses
101954 ** to block on thread (pTask->thread) before accessing aFile[1]. But, since
105416 ** as if it were part of the sub-query, not the parent. This block
112261 ** Allocate or deallocate a block of nReg consecutive registers.
124623 ** Return a register number which is the first in a block of
124625 ** block of registers has already been deallocated by the time
129436 /* Allocate a block registers to hold the rowid and the values
129699 /* This block codes the top of loop only. The complete loop is the
129711 /* This block codes the top of loop only. The complete loop is the
129762 ** to a second block of registers, so the register needs to be
131011 ** the next retest block */
131622 ** DBFLAG_Vacuum flag is set, this block generates code to make
136816 /* The following block is a no-op unless SQLITE_DEBUG is defined. Its only
138263 int regReturn; /* Register holding block-output return address */
138264 int labelBkOut; /* Start label for the block-output subroutine */
142674 ** followed by any ORDER BY, LIMIT and/or OFFSET clauses. This block
142797 ** block of code will expand the outer query FROM clause to 4 slots.
145879 ** block. If there were no changes, this block is skipped.
146524 ** exist, the error is caught by the block below.
149848 ** both transactions are closed by this block - the main database
151345 ** This object is a header on a block of allocated memory that will be
151349 WhereMemBlock *pNext; /* Next block in the chain */
156617 ** block sorting is required.
158042 ** Often, sample i of each block of N effective samples has (i+1) fields.
158045 ** sample 2 is the first sample of a block of N samples, so at first it
158089 ** above found the right answer. This block serves no purpose other
159562 ** "x IN(...)" terms are replaced with "x = ?". This block updates
161288 ** terms are out of order, then block-sorting will reduce the
161971 ** This block of code merely checks to see if a Bloom filter would be
165264 ** reg2 are NULL are handled separately in the following block. The code
165277 ** block. */
165279 /* This block runs if reg1 contains a NULL. */
165297 /* This block runs if reg1 is not NULL, but reg2 is. */
165305 ** This block adds (or subtracts for DESC) the numeric value in regVal
166028 ** at regNew. If the window has a PARTITION clause, this block generates
166055 /* This block is run for the first row of each partition */
166104 /* Beginning of the block executed for the second and subsequent rows. */
173591 ** threads must block until the first thread finishes with the initialization.
173594 ** calls to this routine should not block, of course. Otherwise the
173601 ** * Calls to this routine from Y must block until the outer-most
176668 ** dealt with in the previous code block. Besides these, the only
176837 ** do not block illegal combinations here, it could trigger
177309 /* The following block stores the meta information that will be returned
178872 ** varint iBlockid; (block id of node's leftmost subtree)
178925 ** end_block - last block (including interior nodes)
180359 "CREATE TABLE %Q.'%q_segments'(blockid INTEGER PRIMARY KEY, block BLOB);",
181905 ** POS_END (0) or POS_COLUMN (1). The following block merges the two lists
183164 ** involves updating the leaf block that contains the smallest unmerged
183165 ** entry and each block (if any) between the leaf and the root node. So
185072 /* The following block runs if pExpr is the root of a NEAR query.
186615 ** The first pass, in the block below, uses a tokenizer cursor to iterate
186625 ** The second pass, in the block that begins "if( rc==SQLITE_DONE )" below,
189525 ** single block of memory. It then dequotes any of the strings that appear
190029 sqlite3_int64 iStartBlock; /* Rowid of first leaf block to traverse */
190030 sqlite3_int64 iLeafEndBlock; /* Rowid of final leaf block to traverse */
190031 sqlite3_int64 iEndBlock; /* Rowid of final block in segment (or 0) */
190032 sqlite3_int64 iCurrentBlock; /* Current leaf block (or 0) */
190082 char *aData; /* Pointer to block from malloc() */
190190 /* 9 */ "REPLACE INTO %Q.'%q_segments'(blockid, block) VALUES(?, ?)",
190259 /* 34 */ "SELECT 1 FROM %Q.'%q_segments' WHERE blockid=? AND block IS NULL",
190448 ** So, for a system with nPrefix prefix indexes configured, the block of
191060 ** CREATE TABLE %_segments(blockid INTEGER PRIMARY KEY, block BLOB)
191065 ** with the contents of the blob stored in the "block" column of the
191104 p->db, p->zDb, p->zSegmentsTbl, "block", iBlockid, 0, &p->pSegments
191394 ** following block advances it to point one byte past the end of
191506 sqlite3_int64 iEndBlock, /* Final block of segment */
191645 ** within this entire function, not just this "else{...}" block.
191813 sqlite3_int64 iBlock, /* Block id for new block */
191814 char *z, /* Pointer to buffer containing block data */
192280 sqlite3_int64 iLast = 0; /* Largest block id written to database */
192281 sqlite3_int64 iLastLeaf; /* Largest leaf block id written to db */
193589 sqlite3_int64 iBlock; /* Current block id */
193590 Blob key; /* Last key written to the current block */
193591 Blob block; /* Current block image */
193603 sqlite3_int64 iStart; /* Block number of first allocated block */
193604 sqlite3_int64 iEnd; /* Block number of last allocated block */
193739 ** The block id of the leaf node just written to disk may be found in
193770 if( pNode->key.n==0 || (pNode->block.n + nSpace)<=p->nNodeSize ){
193775 Blob *pBlk = &pNode->block;
193803 rc = fts3WriteSegment(p, pNode->iBlock, pNode->block.a, pNode->block.n);
193805 assert( pNode->block.nAlloc>=p->nNodeSize );
193806 pNode->block.a[0] = (char)iLayer;
193807 pNode->block.n = 1 + sqlite3Fts3PutVarint(&pNode->block.a[1], iPtr+1);
193921 /* If the current block is not empty, and if adding this term/doclist
193922 ** to the current block would make it larger than Fts3Table.nNodeSize
193923 ** bytes, write this block out to the database. */
193924 if( pLeaf->block.n>0 && (pLeaf->block.n + nSpace)>p->nNodeSize ){
193925 rc = fts3WriteSegment(p, pLeaf->iBlock, pLeaf->block.a, pLeaf->block.n);
193944 /* Advance to the next output block */
193947 pLeaf->block.n = 0;
193956 blobGrowBuffer(&pLeaf->block, pLeaf->block.n + nSpace, &rc);
193958 if( pLeaf->block.n==0 ){
193959 pLeaf->block.n = 1;
193960 pLeaf->block.a[0] = '\0';
193963 &pLeaf->block, &pLeaf->key, zTerm, nTerm, aDoclist, nDoclist
193999 if( pNode->block.n>0 ) break;
194000 assert( *pRc || pNode->block.nAlloc==0 );
194002 sqlite3_free(pNode->block.a);
194025 Blob *pBlock = &pWriter->aNodeWriter[1].block;
194040 if( pNode->block.n>0 && rc==SQLITE_OK ){
194041 rc = fts3WriteSegment(p, pNode->iBlock, pNode->block.a, pNode->block.n);
194043 sqlite3_free(pNode->block.a);
194056 pRoot->block.a, pRoot->block.n /* root */
194059 sqlite3_free(pRoot->block.a);
194224 blobGrowBuffer(&pNode->block,
194228 memcpy(pNode->block.a, aRoot, nRoot);
194229 pNode->block.n = nRoot;
194230 memset(&pNode->block.a[nRoot], 0, FTS3_NODE_PADDING);
194237 if( pNode->block.a){
194238 rc = nodeReaderInit(&reader, pNode->block.a, pNode->block.n);
194253 blobGrowBuffer(&pNode->block,
194257 memcpy(pNode->block.a, aBlock, nBlock);
194258 pNode->block.n = nBlock;
194259 memset(&pNode->block.a[nBlock], 0, FTS3_NODE_PADDING);
194323 ** array of leaf nodes starts at the first block allocated. The array
194324 ** of interior nodes that are parents of the leaf nodes start at block
194341 sqlite3_stmt *pFirstBlock = 0; /* SQL used to determine first block */
194355 /* Calculate the first block to use in the output segment */
194561 Blob block = {0,0,0}; /* Buffer used for any other block */
194589 rc = fts3TruncateNode(aBlock, nBlock, &block, zTerm, nTerm, &iBlock);
194592 rc = fts3WriteSegment(p, iNewStart, block.a, block.n);
194624 sqlite3_free(block.a);
194844 ** to the level identified by the block above (if any). If so, this
194854 /* Based on the scan in the block above, it is known that there
195178 /* This block calculates the checksum according to the FTS index. */
195195 /* This block calculates the checksum according to the %_content table */
196379 ** document nDesired tokens. This block checks if there are actually
204259 ** record to delete from the r-tree table. The following block does
206994 ** record to delete from the r-tree table. The following block does
208893 } /* end of the 'extern "C"' block */
209867 ** Attempt to allocate and return a pointer to a zeroed block of nByte
212550 /* At one point the following block copied a single frame from the
213873 /* A main database has just been opened. The following block sets
216916 ** It is not possible for an OOM to occur in this block. */
218834 ** is currently completely empty. This block shifts the PK fields from
221925 } /* end of the 'extern "C"' block */
227094 /* This block advances the phrase iterators until they point to a set of
230067 ** CREATE TABLE %_data(id INTEGER PRIMARY KEY, block BLOB);
230664 pConfig->zDb, p->zDataTbl, "block", iRowid, 0, &p->pReader
230671 ** table, missing row, non-blob/text in block column - indicate
230757 "REPLACE INTO '%q'.'%q_data'(id, block) VALUES(?,?)",
231454 /* Currently iOff points to the first byte of a varint. This block
232140 ** this block is particularly performance critical, so equivalent
232449 /* This block sets stack variable iPg to the leaf page number that may
235425 pConfig, "data", "id INTEGER PRIMARY KEY, block BLOB", 0, pzErr
235770 "block", FTS5_STRUCTURE_ROWID, 1, &pBlob
236263 ** entries). This block checks that a checksum calculated based on the
240664 ** %_content table. This block stores the checksum in ctx.cksum. */