Lines Matching defs:offset
1159 int (*xShmLock)(sqlite3_file*, int offset, int n, int flags);
1868 ** between 0 and this upper bound as its "offset" argument.
2729 ** integer found at offset 44 into the database header) of 1. This in turn
4204 ** SQL, the sqlite3_error_offset() interface returns the byte offset
4205 ** of the start of that token. ^The byte offset returned by
4809 ** that parameter must be the byte offset
6209 ** must be the byte offset into the string where the NUL terminator would
6211 ** in the string at a byte offset that is less than the value of the 3rd
7956 ** from the open BLOB, starting at offset iOffset.)^
7958 ** ^If offset iOffset is less than N bytes from the end of the BLOB,
7985 ** into the open BLOB, starting at offset iOffset.)^
7999 ** ^If offset iOffset is less than N bytes from the end of the BLOB,
12814 ** to the column in which it occurs and *piOff the token offset of the
12909 ** // An instance of phrase iPhrase at offset iOff of column iCol
13205 int iStart, /* Byte offset of token within input text */
13206 int iEnd /* Byte offset of end of token within input text */
15114 SQLITE_PRIVATE int sqlite3OsRead(sqlite3_file*, void*, int amt, i64 offset);
15115 SQLITE_PRIVATE int sqlite3OsWrite(sqlite3_file*, const void*, int amt, i64 offset);
15560 ** to constants so that the offset of the corresponding field in an
15563 ** offset = 36 + (idx * 4)
15565 ** For example, the free-page-count field is located at byte offset 36 of
15567 ** byte offset 64 (== 36+4*7).
15749 SQLITE_PRIVATE int sqlite3BtreePayload(BtCursor*, u32 offset, u32 amt, void*);
15759 SQLITE_PRIVATE int sqlite3BtreePayloadChecked(BtCursor*, u32 offset, u32 amt, void*);
15760 SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor*, u32 offset, u32 amt, void*);
17024 int errByteOffset; /* Byte offset of error in SQL statement */
17589 ** than the offset into these arrays for the corresponding name.
23574 int tz; /* Timezone offset in minutes */
24069 DateTime *p, /* Date at which to calculate offset */
24951 SQLITE_PRIVATE int sqlite3OsRead(sqlite3_file *id, void *pBuf, int amt, i64 offset){
24953 return id->pMethods->xRead(id, pBuf, amt, offset);
24955 SQLITE_PRIVATE int sqlite3OsWrite(sqlite3_file *id, const void *pBuf, int amt, i64 offset){
24957 return id->pMethods->xWrite(id, pBuf, amt, offset);
25033 SQLITE_PRIVATE int sqlite3OsShmLock(sqlite3_file *id, int offset, int n, int flags){
25034 return id->pMethods->xShmLock(id, offset, n, flags);
27444 int iOffset; /* An offset into mem5.aCtrl[] */
30871 ** byte offset recorded, try to compute the error byte offset for
30872 ** z and set the error byte offset in db.
30892 ** If pExpr has a byte offset for the start of a token, record that as
30893 ** as the error offset.
38495 ** range', a range of 510 bytes at a well known offset.
39617 unsigned long long offset; /* offset to first byte to lock */
39636 unsigned long long offset, /* First byte to be locked */
39645 pb.offset = offset;
39651 offset, length));
40105 ** Seek to the offset passed as the second argument, then read cnt
40117 static int seekAndRead(unixFile *id, sqlite3_int64 offset, void *pBuf, int cnt){
40128 got = osPread(id->h, pBuf, cnt, offset);
40131 got = osPread64(id->h, pBuf, cnt, offset);
40134 newOffset = lseek(id->h, offset, SEEK_SET);
40150 offset += got;
40157 id->h, got+prior, offset-prior, TIMER_ELAPSED));
40170 sqlite3_int64 offset
40175 assert( offset>=0 );
40182 || offset>=PENDING_BYTE+512
40183 || offset+amt<=PENDING_BYTE
40190 if( offset<pFile->mmapSize ){
40191 if( offset+amt <= pFile->mmapSize ){
40192 memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], amt);
40195 int nCopy = pFile->mmapSize - offset;
40196 memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], nCopy);
40199 offset += nCopy;
40204 got = seekAndRead(pFile, offset, pBuf, amt);
40225 sqlite3_log(SQLITE_IOERR_CORRUPTFS, "unixRead-EDEVERR, fd:[%d], amt[%d], got[%d], offset[%lld]", pFile->h, amt, got, offset);
40230 sqlite3_log(SQLITE_IOERR_READ, "unixRead-got<0, fd: [%d], amt[%d], got[%d], offset[%lld]", pFile->h, amt, got, offset);
40243 ** absolute offset iOff, then attempt to write nBuf bytes of data from
40250 i64 iOff, /* File offset to begin writing at */
40288 ** Seek to the offset in id->offset then read cnt bytes into pBuf.
40289 ** Return the number of bytes actually read. Update the offset.
40294 static int seekAndWrite(unixFile *id, i64 offset, const void *pBuf, int cnt){
40295 return seekAndWriteFd(id->h, offset, pBuf, cnt, &id->lastErrno);
40307 sqlite3_int64 offset
40318 || offset>=PENDING_BYTE+512
40319 || offset+amt<=PENDING_BYTE
40332 if( offset<=24 && offset+amt>=27 ){
40338 if( rc!=4 || memcmp(oldCntr, &((char*)pBuf)[24-offset], 4)!=0 ){
40348 if( offset<pFile->mmapSize ){
40349 if( offset+amt <= pFile->mmapSize ){
40350 memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, amt);
40353 int nCopy = pFile->mmapSize - offset;
40354 memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, nCopy);
40357 offset += nCopy;
40362 while( (wrote = seekAndWrite(pFile, offset, pBuf, amt))<amt && wrote>0 ){
40364 offset += wrote;
40375 "unixWrite, lastErrno set by seekAndWrite, fd[%d], offset[%lld], wrote[%d], amt[%d], lastErrno[%d]",
40377 offset,
40387 "unixWrite, not a system error, fd[%d], offset[%lld], wrote[%d], amt[%d], lastErrno[%d]",
40389 offset,
40762 ** at offset (nSize-1), to set the size of the file correctly.
40768 i64 iWrite; /* Next offset to write to */
42163 ** If possible, return a pointer to a mapping of file fd starting at offset
45049 assert( UNIX_SHM_DMS==128 ); /* Byte offset of the deadman-switch */
47661 ** argument to offset iOffset within the file. If successful, return 0.
47666 LONG upperBits; /* Most sig. 32 bits of new offset */
47667 LONG lowerBits; /* Least sig. 32 bits of new offset */
47671 OSTRACE(("SEEK file=%p, offset=%lld\n", pFile->h, iOffset));
47677 ** containing the lower 32-bits of the new file-offset. Or, if it fails,
47679 ** INVALID_SET_FILE_POINTER may also be a valid new offset. So to determine
47701 LARGE_INTEGER x; /* The new offset */
47797 sqlite3_int64 offset /* Begin reading at this offset */
47800 OVERLAPPED overlapped; /* The offset for ReadFile. */
47808 assert( offset>=0 );
47811 "offset=%lld, lock=%d\n", osGetCurrentProcessId(), pFile,
47812 pFile->h, pBuf, amt, offset, pFile->locktype));
47817 if( offset<pFile->mmapSize ){
47818 if( offset+amt <= pFile->mmapSize ){
47819 memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], amt);
47824 int nCopy = (int)(pFile->mmapSize - offset);
47825 memcpy(pBuf, &((u8 *)(pFile->pMapRegion))[offset], nCopy);
47828 offset += nCopy;
47834 if( winSeekFile(pFile, offset) ){
47842 overlapped.Offset = (LONG)(offset & 0xffffffff);
47843 overlapped.OffsetHigh = (LONG)((offset>>32) & 0x7fffffff);
47877 sqlite3_int64 offset /* Offset into the file to begin writing at */
47889 "offset=%lld, lock=%d\n", osGetCurrentProcessId(), pFile,
47890 pFile->h, pBuf, amt, offset, pFile->locktype));
47895 if( offset<pFile->mmapSize ){
47896 if( offset+amt <= pFile->mmapSize ){
47897 memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, amt);
47902 int nCopy = (int)(pFile->mmapSize - offset);
47903 memcpy(&((u8 *)(pFile->pMapRegion))[offset], pBuf, nCopy);
47906 offset += nCopy;
47912 rc = winSeekFile(pFile, offset);
47918 OVERLAPPED overlapped; /* The offset for WriteFile. */
47927 overlapped.Offset = (LONG)(offset & 0xffffffff);
47928 overlapped.OffsetHigh = (LONG)((offset>>32) & 0x7fffffff);
47946 offset += nWrite;
47947 overlapped.Offset = (LONG)(offset & 0xffffffff);
47948 overlapped.OffsetHigh = (LONG)((offset>>32) & 0x7fffffff);
48877 OSTRACE(("SHM-LOCK file=%p, lock=%d, offset=%d, size=%d\n",
49396 OSTRACE(("SHM-MAP-MAP pid=%lu, region=%d, offset=%d, size=%d, rc=%s\n",
49575 ** If possible, return a pointer to a mapping of file fd starting at offset
49592 OSTRACE(("FETCH pid=%lu, pFile=%p, offset=%lld, amount=%d, pp=%p\n",
49640 OSTRACE(("UNFETCH pid=%lu, pFile=%p, offset=%lld, p=%p\n",
55921 ** the savepoint is active, then iHdrOffset is set to the byte offset
55928 i64 iOffset; /* Starting offset in main journal */
55973 ** (the 4-byte header field at byte offset 24 of the database file) is
56048 ** larger than the size of the database (the value stored at offset
56159 i64 journalOff; /* Current write offset in the journal file */
56160 i64 journalHdr; /* Byte offset to previous journal header */
56609 static int read32bits(sqlite3_file *fd, i64 offset, u32 *pRes){
56611 int rc = sqlite3OsRead(fd, ac, sizeof(ac), offset);
56628 static int write32bits(sqlite3_file *fd, i64 offset, u32 val){
56631 return sqlite3OsWrite(fd, ac, 4, offset);
56851 ** Return the offset of the sector boundary at or immediately
56866 i64 offset = 0;
56869 offset = ((c-1)/JOURNAL_HDR_SZ(pPager) + 1) * JOURNAL_HDR_SZ(pPager);
56871 assert( offset%JOURNAL_HDR_SZ(pPager)==0 );
56872 assert( offset>=c );
56873 assert( (offset-c)<JOURNAL_HDR_SZ(pPager) );
56874 return offset;
57688 ** of the page data, starting with byte offset (pPager->pageSize%200).
57742 ** The page begins at offset *pOffset into the file. The *pOffset
58588 ** the header and the sqlite version number at offset 96.
58891 ** offset PagerSavepoint.iOffset and continuing to
59004 i64 offset = (i64)pSavepoint->iSubRec*(4+pPager->pageSize);
59010 assert( offset==(i64)ii*(4+pPager->pageSize) );
59011 rc = pager_playback_one_page(pPager, &offset, pDone, 0, 1);
59823 ** Variable iNextHdrOffset is set to the offset at which this
59973 i64 offset = (pgno-1)*(i64)pPager->pageSize; /* Offset to write */
59983 rc = sqlite3OsWrite(pPager->fd, pData, pPager->pageSize, offset);
60067 i64 offset = (i64)pPager->nSubRec*(4+pPager->pageSize);
60077 rc = write32bits(pPager->sjfd, offset, pPg->pgno);
60079 rc = sqlite3OsWrite(pPager->sjfd, pData2, pPager->pageSize, offset+4);
60920 ** at offset 24 into the file. The first 4 of these 16 bytes are
61805 ** byte offset 24 of the pager file. The secondary change counter at
61806 ** 92 is also updated, as is the SQLite version number at offset 96.
63649 ** is for the index number to indicate a byte offset into the
63675 ** the locking bytes (WalCkptInfo.aLock) start at offset 120 and
63724 ** to avoid having to offset aReadMark[] indexs by one. Readers holding
63855 ** Return the offset of frame iFrame in the write-ahead log file,
63856 ** assuming a database page size of szPage bytes. The offset returned
64587 int iLock; /* Lock offset to lock for checkpoint */
64883 ** For that matter, if the lock offset ever changes from its initial design
65880 i64 iOffset; /* Current offset when reading wal file */
66860 sqlite3_int64 iSyncPoint; /* Fsync at this offset */
66877 sqlite3_int64 iOffset /* Start writing at this offset */
66902 sqlite3_int64 iOffset /* Byte offset at which to write */
67696 ** 1 2 byte offset to the first freeblock
67719 ** freeblocks. Each freeblock is at least 4 bytes in size. The byte offset
67725 ** in the page header at offset 7.
67728 ** 2 Byte offset of the next freeblock
67856 u16 maskPage; /* Mask for page offset */
68179 ** the offset of the requested map entry.
68633 ** This routine is used to extract the "offset to cell content area" value
68635 ** is empty, the offset should be 65536, but the 2-byte value stores zero.
69617 int offset; /* Offset in pointer map page */
69644 offset = PTRMAP_PTROFFSET(iPtrmap, key);
69645 if( offset<0 ){
69649 assert( offset <= (int)pBt->usableSize-5 );
69652 if( eType!=pPtrmap[offset] || get4byte(&pPtrmap[offset+1])!=parent ){
69656 pPtrmap[offset] = eType;
69657 put4byte(&pPtrmap[offset+1], parent);
69676 int offset; /* Offset of entry in pointer map */
69688 offset = PTRMAP_PTROFFSET(iPtrmap, key);
69689 if( offset<0 ){
69693 assert( offset <= (int)pBt->usableSize-5 );
69695 *pEType = pPtrmap[offset];
69696 if( pPgno ) *pPgno = get4byte(&pPtrmap[offset+1]);
70127 int iCellStart; /* First cell offset in input */
70340 ** then the cell content offset of an empty page wants to be 65536.
70609 int iCellFirst; /* First allowable cell or freeblock offset */
70610 int iCellLast; /* Last possible cell or freeblock offset */
70624 /* EVIDENCE-OF: R-58015-48175 The two-byte integer at offset 5 designates
70632 ** EVIDENCE-OF: R-23588-34450 The two-byte integer at offset 1 gives the
70666 /* At this point, nFree contains the sum of the offset to the start
70670 ** serves to verify that the offset to the start of the cell-content
70685 int iCellFirst; /* First allowable cell or freeblock offset */
70686 int iCellLast; /* Last possible cell or freeblock offset */
70739 /* EVIDENCE-OF: R-28594-02890 The one-byte flag at offset 0 indicating
70751 /* EVIDENCE-OF: R-37002-32774 The two-byte integer at offset 3 gives the
70761 ** offset to the cell content area will equal the page size minus the
71240 ** determined by the 2-byte integer located at an offset of 16 bytes from
71261 ** determined by the one-byte unsigned integer found at an offset of 20
71899 ** determined by the 2-byte integer located at an offset of 16 bytes from
71913 ** integer at offset 20 is the number of bytes of space at the end of
71917 ** determined by the one-byte unsigned integer found at an offset of 20
73396 ** Return the offset into the database file for the start of the
73559 ** A total of "amt" bytes are read or written beginning at "offset".
73568 ** Subsequent calls use this cache to make seeking to the supplied offset
73582 u32 offset, /* Begin reading this far into payload */
73606 assert( offset+amt <= pCur->info.nPayload );
73619 if( offset<pCur->info.nLocal ){
73621 if( a+offset>pCur->info.nLocal ){
73622 a = pCur->info.nLocal - offset;
73624 rc = copyPayload(&aPayload[offset], pBuf, a, eOp, pPage->pDbPage);
73625 offset = 0;
73629 offset -= pCur->info.nLocal;
73667 if( pCur->aOverflow[offset/ovflSize] ){
73668 iIdx = (offset/ovflSize);
73670 offset = (offset%ovflSize);
73683 if( offset>=ovflSize ){
73697 offset -= ovflSize;
73703 if( a + offset > ovflSize ){
73704 a = ovflSize - offset;
73722 && offset==0 /* (2) */
73746 rc = copyPayload(&aPayload[offset+4], pBuf, a, eOp, pDbPage);
73748 offset = 0;
73770 ** begins at "offset".
73781 ** wrong. An error is returned if "offset+amt" is larger than
73784 SQLITE_PRIVATE int sqlite3BtreePayload(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
73788 return accessPayload(pCur, offset, amt, (unsigned char*)pBuf, 0);
73799 u32 offset,
73809 return rc ? rc : accessPayload(pCur, offset, amt, pBuf, 0);
73811 SQLITE_PRIVATE int sqlite3BtreePayloadChecked(BtCursor *pCur, u32 offset, u32 amt, void *pBuf){
73814 return accessPayload(pCur, offset, amt, pBuf, 0);
73816 return accessPayloadChecked(pCur, offset, amt, pBuf);
74898 /* EVIDENCE-OF: R-21003-45125 The 4-byte big-endian integer at offset 36
74952 /* EVIDENCE-OF: R-59841-13798 The 4-byte big-endian integer at offset 32
75994 ** page body, a 16-bit offset is written to pCellptr. And so on, for each
76710 ** offset section of the btree page will be overwritten and we will no
79096 /* EVIDENCE-OF: R-37002-32774 The two-byte integer at offset 3 gives the
79214 ** is the offset of the first freeblock, or zero if there are no
79225 ** big-endian integer which is the offset in the b-tree page of the next
79230 ** increasing offset. */
79263 ** EVIDENCE-OF: R-07161-27322 The one-byte integer at offset 7 gives the
79605 SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor *pCsr, u32 offset, u32 amt, void *z){
79647 return accessPayload(pCsr, offset, amt, (unsigned char *)z, 1);
79660 ** Set both the "read version" (single byte at byte offset 18) and
79661 ** "write version" (single byte at byte offset 19) fields in the database
80025 ** page. For each iteration, variable iOff is set to the byte offset
81783 ** to. offset and amt determine what portion of the data or key to retrieve.
81797 u32 offset, /* Offset from the start of data to return bytes from. */
81803 if( sqlite3BtreeMaxRecordSize(pCur)<offset+amt ){
81807 rc = sqlite3BtreePayload(pCur, offset, amt, pMem->z);
85410 i64 offset = 0;
85467 rc = sqlite3OsWrite(pSuperJrnl, zFile, sqlite3Strlen30(zFile)+1,offset);
85468 offset += sqlite3Strlen30(zFile)+1;
93114 ** Store in register r[P3] the byte offset into the database file that is the
93174 u32 *aOffset; /* aOffset[i] is offset to start of data for i-th column */
93182 u64 offset64; /* 64-bit offset */
93664 ** hdr-size field is also a varint which is the offset from the beginning
97723 ** holds the offset counter. The opcode computes the combined value
99284 int iOffset; /* Byte offset of blob in cursor data */
99571 ** and offset cache without causing any IO.
100127 i64 iReadOff; /* Current read offset */
100166 ** at offset iStartOff of file pTask->file2. And instead of using a
100211 ** SorterRecord.u.iNext offset. This is because the aMemory[] array may
100403 ** that file) and seek it to offset iOff within the file. Return SQLITE_OK
100493 ** starting at offset iStart and ending at offset iEof-1. This function
100503 i64 iStart, /* Start offset in pFile */
101281 ** Before returning, set *piEof to the offset immediately following the
102078 ** When this function is called, *piOffset is set to the offset of the
102080 ** set to the offset immediately following the last byte of the last
102087 i64 *piOffset, /* IN/OUT: Readr offset in pTask->file */
103062 sqlite_int64 iOfst /* Begin reading at this offset */
103163 sqlite_int64 iOfst /* Begin writing at this offset into the file */
108544 ** offset of the index column that matches the i'th column returned by the
118562 ** find the (first) offset of that column in index pIdx. Or return -1
119542 ** parameter is a pointer to an integer that contains the offset at
119545 ** to the specified offset in the buffer and updates *pIdx to refer
123900 ** is a limit/offset term to enforce.
123906 /* Generate a select expression tree to enforce the limit/offset
139041 int iOffset, /* Register holding the offset counter */
140637 ** the limit and offset. If there is no limit and/or offset, then
140641 ** a limit or offset is defined by pLimit->pLeft and pLimit->pRight. iLimit
140651 ** the reuse of the same limit and offset registers across multiple
140692 pParse->nMem++; /* Allocate an extra register for limit+offset */
150876 ** called is identified by the second argument, "offset", which is
150877 ** the offset of the method to call in the sqlite3_module structure.
150881 static void callFinaliser(sqlite3 *db, int offset){
150891 x = *(int (**)(sqlite3_vtab *))((char *)p->pModule + offset);
151456 u32 bOmitOffset : 1; /* True to let virtual table handle offset */
151941 #define WHERE_OMIT_OFFSET 0x01000000 /* Set offset counter to zero */
156250 int iReg, /* Register that will hold value of the limit/offset */
156251 Expr *pExpr, /* Expression that defines the limit/offset */
163238 ** lead(expr [, offset [, default]])
163239 ** lag(expr [, offset [, default]])
163810 "RANGE with offset PRECEDING/FOLLOWING requires one ORDER BY expression"
164284 ** The argument expression is an PRECEDING or FOLLOWING offset. The
164603 "frame starting offset must be a non-negative integer",
164604 "frame ending offset must be a non-negative integer",
164606 "frame starting offset must be a non-negative number",
164607 "frame ending offset must be a non-negative number",
165199 ** offset PRECEDING/FOLLOWING frame boundaries. Assuming "ASC" order for
166816 ** yy_shift_ofst[] For each state, the offset into yy_action for
166818 ** yy_reduce_ofst[] For each state, the offset into yy_action for
176031 ** Return the byte offset of the most recent error
179172 int *piStartOffset, /* OUT: Byte offset of token in input buffer */
179173 int *piEndOffset, /* OUT: Byte offset of end of token in input buffer */
188599 int *piStartOffset, /* OUT: Starting offset of token */
188600 int *piEndOffset, /* OUT: Ending offset of token */
189350 int *piStartOffset, /* OUT: Starting offset of token */
189351 int *piEndOffset, /* OUT: Ending offset of token */
189461 ** start: Byte offset of the token within the input <string>.
189462 ** end: Byte offset of the byte immediately following the end of the
189464 ** pos: Token offset of token within input.
191355 ** *ppOffsetList is set to point to the first column-offset list
191357 ** *pnOffsetList is set to the length of the set of column-offset
191393 /* Pointer p currently points at the first byte of an offset list. The
191395 ** the same offset list. */
191414 ** size of the previous offset-list.
191426 ** Fts3SegReader.pOffsetList to point to the next offset list before
193621 int iOff; /* Current offset within aNode[] */
196080 ** candidate always starts at offset 0 (even if this candidate has a
196085 /* Advance the 'head' iterator of each phrase to the first offset that
196438 int iEnd = 0; /* Byte offset of end of current token */
197326 /* Loop through the table columns, appending offset information to
197552 int iOff; /* Current offset within aInput[] */
197777 int *piStart, /* OUT: Starting offset of token */
197778 int *piEnd, /* OUT: Ending offset of token */
205795 ** geopoly_xform(poly, 1, 0, 0, 1, x-offset, y-offset)
208088 int *piStartOffset, /* OUT: Starting offset of token */
208089 int *piEndOffset, /* OUT: Ending offset of token */
211782 ** blob starting at byte offset 40.
211893 ** Called when iAmt bytes are read from offset iOff of the wal file while
211925 ** Called when a page of data is written to offset iOff of the database
214700 ** offset from ZIPVFS.
214708 /* Not ZIPVFS: The default page size and offset */
221475 ** to the column in which it occurs and *piOff the token offset of the
221570 ** // An instance of phrase iPhrase at offset iOff of column iCol
221866 int iStart, /* Byte offset of token within input text */
221867 int iEnd /* Byte offset of end of token within input text */
221994 ** (65536-1-1-4-9)==65521 bytes. The limiting factor is the 16-bit offset
222240 int i; /* Current offset in a[] */
222264 i64 *piOff /* IN/OUT: Current offset */
223032 ** fts5yy_shift_ofst[] For each state, the offset into fts5yy_action for
223034 ** fts5yy_reduce_ofst[] For each state, the offset into fts5yy_action for
224396 int iPos; /* Current token offset in zIn[] */
224403 int iOff; /* Current offset within zIn[] */
224436 int iStartOff, /* Start offset of token */
224437 int iEndOff /* End offset of token */
224572 int iStartOff, /* Start offset of token */
224573 int iEndOff /* End offset of token */
224606 int iPos, /* Starting offset to score */
224609 int *piPos /* OUT: Adjusted offset */
225166 i64 *piOff /* IN/OUT: Current offset */
225544 ** If the close-quote is found, the value returned is the byte offset of
226108 ** int iStart // Byte offset of start of token within input text
226109 ** int iEnd // Byte offset of end of token within input text
227000 int i; /* Current offset in position list */
228037 int iUnused1, /* Start offset of token */
228038 int iUnused2 /* End offset of token */
229288 int iUnused1, /* Byte offset of token within input text */
229289 int iUnused2 /* Byte offset of end of token within input text */
229763 ** + 5 bytes for the new position offset (32-bit max).
229816 /* Append the new position offset, if necessary */
230145 ** varint: first offset + 2
230147 ** varint: offset delta + 2
230155 ** * The byte offset of the first rowid on the page, if it exists
230158 ** * The byte offset of the start of the page footer. If the page
230163 ** on the page. Each varint is the byte offset of the current term
230165 ** other words, the first varint in the footer is the byte offset of
230166 ** the first term, the second is the byte offset of the second less that
230398 ** Byte offset within the current leaf that is the first byte of the
230409 ** the offset immediately following the term data.
230427 ** corresponding aRowidOffset[] entry is set to the byte offset of the
230439 i64 iLeafOffset; /* Byte offset within current leaf */
230444 /* The page and offset from which the current term was read. The offset
230445 ** is the offset of the first rowid in the current doclist. */
230449 int iPgidxOff; /* Next offset in pgidx */
230455 int *aRowidOffset; /* Array of offset to rowid fields */
230542 ** Set to the current offset within record pData.
230546 int iOff; /* Current offset into pData */
231798 ** Fts5SegIter.iLeafOffset variable is set to the offset of the start of
232301 u32 iPgidx; /* Current offset in pgidx */
236964 ** the value of which is the offset within aPoslist[] following the last
238861 int iUnused1, /* Start offset of token */
238862 int iUnused2 /* End offset of token */
240129 int iUnused1, /* Start offset of token */
240130 int iUnused2 /* End offset of token */
240578 int iUnused1, /* Start offset of token */
240579 int iUnused2 /* End offset of token */
243498 ** CREATE TABLE vocab(term, doc, col, offset, PRIMARY KEY(<all-fields>));
243552 #define FTS5_VOCAB_INST_SCHEMA "term, doc, col, offset"
243985 int iOff = 0; /* Current offset within position list */
245640 int offset = 0;
245647 offset = FILE_HEADER_SIZE;
245661 rc = sqlite3CodecDecryptData(pCtx, OPERATE_CONTEXT_READ, pgno, cipherPageSize - offset, (unsigned char *)(pData + offset), pCtx->buffer + offset);
245676 rc = sqlite3CodecEncryptData(pCtx, OPERATE_CONTEXT_WRITE, pgno, cipherPageSize - offset, (unsigned char *)(pData + offset), pCtx->buffer + offset);
245691 rc = sqlite3CodecEncryptData(pCtx, OPERATE_CONTEXT_READ, pgno, cipherPageSize - offset, (unsigned char *)(pData + offset), pCtx->buffer + offset);