Lines Matching defs:iOffset
5837 ** from the open BLOB, starting at offset iOffset.)^
5839 ** ^If offset iOffset is less than N bytes from the end of the BLOB,
5840 ** [SQLITE_ERROR] is returned and no data is read. ^If N or iOffset is
5842 ** ^The size of the blob (and hence the maximum value of N+iOffset)
5858 SQLITE_API int sqlite3_blob_read(sqlite3_blob *, void *Z, int N, int iOffset);
5865 ** into the open BLOB, starting at offset iOffset.
5873 ** ^If offset iOffset is less than N bytes from the end of the BLOB,
5876 ** The size of the BLOB (and hence the maximum value of N+iOffset)
5896 SQLITE_API int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset);
11693 int iLimit, iOffset; /* Memory registers holding LIMIT & OFFSET counters */
18246 int iOffset; /* An offset into mem5.aCtrl[] */
18277 iOffset = 0;
18280 if( (iOffset+nAlloc)<=mem5.nBlock ){
18281 mem5.aCtrl[iOffset] = ii | CTRL_FREE;
18282 memsys5Link(iOffset, ii);
18283 iOffset += nAlloc;
18285 assert((iOffset+nAlloc)>mem5.nBlock);
34308 ** argument to offset iOffset within the file. If successful, return 0.
34311 static int winSeekFile(winFile *pFile, sqlite3_int64 iOffset){
34318 OSTRACE(("SEEK file=%p, offset=%lld\n", pFile->h, iOffset));
34320 upperBits = (LONG)((iOffset>>32) & 0x7fffffff);
34321 lowerBits = (LONG)(iOffset & 0xffffffff);
34351 x.QuadPart = iOffset;
35853 int iOffset = pShmNode->nRegion*szRegion;
35854 int iOffsetShift = iOffset % winSysInfo.dwAllocationGranularity;
35857 iOffset - iOffsetShift, szRegion + iOffsetShift
35861 0, iOffset - iOffsetShift, szRegion + iOffsetShift
35865 osGetCurrentProcessId(), pShmNode->nRegion, iOffset,
35884 int iOffset = iRegion*szRegion;
35885 int iOffsetShift = iOffset % winSysInfo.dwAllocationGranularity;
40692 i64 iOffset; /* Starting offset in main journal */
43137 i64 iOffset = (pgno-1)*(i64)pPager->pageSize;
43138 rc = sqlite3OsRead(pPager->fd, pPg->pData, pgsz, iOffset);
43491 ** offset PagerSavepoint.iOffset and continuing to
43552 ** PagerSavepoint.iOffset and continuing to the next journal header.
43560 pPager->journalOff = pSavepoint->iOffset;
46739 aNew[ii].iOffset = pPager->journalOff;
46741 aNew[ii].iOffset = JOURNAL_HDR_SZ(pPager);
48578 i64 iOffset; /* Next offset to read from log file */
48638 for(iOffset=WAL_HDRSIZE; (iOffset+szFrame)<=nSize; iOffset+=szFrame){
48644 rc = sqlite3OsRead(pWal->pWalFd, aFrame, szFrame, iOffset);
49220 i64 iOffset;
49223 iOffset = walFrameOffset(iFrame, szPage) + WAL_FRAME_HDRSIZE;
49224 /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL file */
49225 rc = sqlite3OsRead(pWal->pWalFd, zBuf, szPage, iOffset);
49227 iOffset = (iDbpage-1)*(i64)szPage;
49228 testcase( IS_BIG_INT(iOffset) );
49229 rc = sqlite3OsWrite(pWal->pDbFd, zBuf, szPage, iOffset);
49885 i64 iOffset;
49890 iOffset = walFrameOffset(iRead, sz) + WAL_FRAME_HDRSIZE;
49891 /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL */
49892 return sqlite3OsRead(pWal->pWalFd, pOut, (nOut>sz ? sz : nOut), iOffset);
50138 ** Write iAmt bytes of content into the WAL file beginning at iOffset.
50141 ** In other words, if iSyncPoint is in between iOffset and iOffset+iAmt,
50149 sqlite3_int64 iOffset /* Start writing at this offset */
50152 if( iOffset<p->iSyncPoint && iOffset+iAmt>=p->iSyncPoint ){
50153 int iFirstAmt = (int)(p->iSyncPoint - iOffset);
50154 rc = sqlite3OsWrite(p->pFd, pContent, iFirstAmt, iOffset);
50156 iOffset += iFirstAmt;
50163 rc = sqlite3OsWrite(p->pFd, pContent, iAmt, iOffset);
50174 sqlite3_int64 iOffset /* Byte offset at which to write */
50185 rc = walWriteToLog(p, aFrame, sizeof(aFrame), iOffset);
50188 rc = walWriteToLog(p, pData, p->szPage, iOffset+sizeof(aFrame));
50210 i64 iOffset; /* Next byte to write in WAL file */
50285 iOffset = walFrameOffset(iFrame+1, szPage);
50292 assert( iOffset==walFrameOffset(iFrame, szPage) );
50294 rc = walWriteOneFrame(&w, p, nDbSize, iOffset);
50297 iOffset += szFrame;
50317 w.iSyncPoint = ((iOffset+sectorSize-1)/sectorSize)*sectorSize;
50318 while( iOffset<w.iSyncPoint ){
50319 rc = walWriteOneFrame(&w, pLast, nTruncate, iOffset);
50321 iOffset += szFrame;
74560 int iOffset; /* Byte offset of blob in cursor data */
74609 p->iOffset = pC->aType[p->iCol + pC->nField];
74890 int iOffset,
74903 if( n<0 || iOffset<0 || (iOffset+n)>p->nByte ){
74918 rc = xCall(p->pCsr, iOffset+p->iOffset, n, z);
74936 SQLITE_API int sqlite3_blob_read(sqlite3_blob *pBlob, void *z, int n, int iOffset){
74937 return blobReadWrite(pBlob, z, n, iOffset, sqlite3BtreeData);
74943 SQLITE_API int sqlite3_blob_write(sqlite3_blob *pBlob, const void *z, int n, int iOffset){
74944 return blobReadWrite(pBlob, (void *)z, n, iOffset, sqlite3BtreePutData);
76401 sqlite3_int64 iOffset; /* Offset from the beginning of the file */
76433 assert( iOfst+iAmt<=p->endpoint.iOffset );
76435 if( p->readpoint.iOffset!=iOfst || iOfst==0 ){
76456 p->readpoint.iOffset = iOfst+iAmt;
76478 assert( iOfst==p->endpoint.iOffset );
76483 int iChunkOffset = (int)(p->endpoint.iOffset%JOURNAL_CHUNKSIZE);
76506 p->endpoint.iOffset += iSpace;
76557 *pSize = (sqlite_int64) p->endpoint.iOffset;
79292 pNew->iOffset = 0;
98687 static const u8 iOffset[] = {0, 1, 2, 4, 9, 12, 16};
98696 if( iLength[i]==n && sqlite3StrNICmp(&zText[iOffset[i]],z,n)==0 ){
101968 if( pSelect->iOffset ){
101969 iLimit = pSelect->iOffset+1;
101988 int iOffset, /* Register holding the offset counter */
101991 if( iOffset>0 ){
101993 addr = sqlite3VdbeAddOp3(v, OP_IfNeg, iOffset, 0, -1); VdbeCoverage(v);
102085 codeOffset(v, p->iOffset, iContinue);
102175 codeOffset(v, p->iOffset, iContinue);
102607 codeOffset(v, p->iOffset, addrContinue);
102614 codeOffset(v, p->iOffset, addrContinue);
103168 ** Compute the iLimit and iOffset fields of the SELECT based on the
103171 ** keywords. Or NULL if those keywords are omitted. iLimit and iOffset
103174 ** iLimit and iOffset are negative.
103176 ** This routine changes the values of iLimit and iOffset only if
103178 ** iOffset should have been preset to appropriate default values (zero)
103181 ** The iOffset register (if it exists) is initialized to the value
103183 ** iOffset+1 is initialized to LIMIT+OFFSET.
103193 int iOffset;
103224 p->iOffset = iOffset = ++pParse->nMem;
103226 sqlite3ExprCode(pParse, p->pOffset, iOffset);
103227 sqlite3VdbeAddOp1(v, OP_MustBeInt, iOffset); VdbeCoverage(v);
103229 addr1 = sqlite3VdbeAddOp1(v, OP_IfPos, iOffset); VdbeCoverage(v);
103230 sqlite3VdbeAddOp2(v, OP_Integer, 0, iOffset);
103232 sqlite3VdbeAddOp3(v, OP_Add, iLimit, iOffset, iOffset+1);
103235 sqlite3VdbeAddOp2(v, OP_Integer, -1, iOffset+1);
103371 regOffset = p->iOffset;
103373 p->iLimit = p->iOffset = 0;
103589 pPrior->iOffset = p->iOffset;
103601 p->iOffset = pPrior->iOffset;
103693 p->iOffset = 0;
103912 codeOffset(v, p->iOffset, iContinue);
104129 int savedOffset; /* Saved value of p->iOffset */
104246 sqlite3VdbeAddOp2(v, OP_Copy, p->iOffset ? p->iOffset+1 : p->iLimit,
104283 savedOffset = p->iOffset;
104285 p->iOffset = 0;
104289 p->iOffset = savedOffset;
134903 int iOffset; /* current position in zInput */
134963 c->iOffset = 0; /* start tokenizing at the beginning */
135459 while( c->iOffset<c->nInput ){
135463 while( c->iOffset<c->nInput && isDelim(z[c->iOffset]) ){
135464 c->iOffset++;
135468 iStartOffset = c->iOffset;
135469 while( c->iOffset<c->nInput && !isDelim(z[c->iOffset]) ){
135470 c->iOffset++;
135473 if( c->iOffset>iStartOffset ){
135474 int n = c->iOffset-iStartOffset;
135485 *piEndOffset = c->iOffset;
136051 int iOffset; /* current position in pInput */
136140 c->iOffset = 0; /* start tokenizing at the beginning */
136176 while( c->iOffset<c->nBytes ){
136180 while( c->iOffset<c->nBytes && simpleDelim(t, p[c->iOffset]) ){
136181 c->iOffset++;
136185 iStartOffset = c->iOffset;
136186 while( c->iOffset<c->nBytes && !simpleDelim(t, p[c->iOffset]) ){
136187 c->iOffset++;
136190 if( c->iOffset>iStartOffset ){
136191 int i, n = c->iOffset-iStartOffset;
136209 *piEndOffset = c->iOffset;
