Lines Matching defs:iOffset
6136 ** from the open BLOB, starting at offset iOffset.)^
6138 ** ^If offset iOffset is less than N bytes from the end of the BLOB,
6139 ** [SQLITE_ERROR] is returned and no data is read. ^If N or iOffset is
6141 ** ^The size of the blob (and hence the maximum value of N+iOffset)
6157 SQLITE_API int sqlite3_blob_read(sqlite3_blob *, void *Z, int N, int iOffset);
6164 ** into the open BLOB, starting at offset iOffset.
6172 ** ^If offset iOffset is less than N bytes from the end of the BLOB,
6175 ** The size of the BLOB (and hence the maximum value of N+iOffset)
6195 SQLITE_API int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset);
11306 int iLimit, iOffset; /* Memory registers holding LIMIT & OFFSET counters */
17582 int iOffset; /* An offset into mem5.aCtrl[] */
17613 iOffset = 0;
17616 if( (iOffset+nAlloc)<=mem5.nBlock ){
17617 mem5.aCtrl[iOffset] = ii | CTRL_FREE;
17618 memsys5Link(iOffset, ii);
17619 iOffset += nAlloc;
17621 assert((iOffset+nAlloc)>mem5.nBlock);
32737 ** argument to offset iOffset within the file. If successful, return 0.
32740 static int seekWinFile(winFile *pFile, sqlite3_int64 iOffset){
32747 OSTRACE(("SEEK file=%p, offset=%lld\n", pFile->h, iOffset));
32749 upperBits = (LONG)((iOffset>>32) & 0x7fffffff);
32750 lowerBits = (LONG)(iOffset & 0xffffffff);
32780 x.QuadPart = iOffset;
34251 int iOffset = pShmNode->nRegion*szRegion;
34252 int iOffsetShift = iOffset % winSysInfo.dwAllocationGranularity;
34255 iOffset - iOffsetShift, szRegion + iOffsetShift
34259 0, iOffset - iOffsetShift, szRegion + iOffsetShift
34263 osGetCurrentProcessId(), pShmNode->nRegion, iOffset,
34282 int iOffset = iRegion*szRegion;
34283 int iOffsetShift = iOffset % winSysInfo.dwAllocationGranularity;
38778 i64 iOffset; /* Starting offset in main journal */
41213 i64 iOffset = (pgno-1)*(i64)pPager->pageSize;
41214 rc = sqlite3OsRead(pPager->fd, pPg->pData, pgsz, iOffset);
41567 ** offset PagerSavepoint.iOffset and continuing to
41628 ** PagerSavepoint.iOffset and continuing to the next journal header.
41636 pPager->journalOff = pSavepoint->iOffset;
44760 aNew[ii].iOffset = pPager->journalOff;
44762 aNew[ii].iOffset = JOURNAL_HDR_SZ(pPager);
46594 i64 iOffset; /* Next offset to read from log file */
46654 for(iOffset=WAL_HDRSIZE; (iOffset+szFrame)<=nSize; iOffset+=szFrame){
46660 rc = sqlite3OsRead(pWal->pWalFd, aFrame, szFrame, iOffset);
47236 i64 iOffset;
47239 iOffset = walFrameOffset(iFrame, szPage) + WAL_FRAME_HDRSIZE;
47240 /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL file */
47241 rc = sqlite3OsRead(pWal->pWalFd, zBuf, szPage, iOffset);
47243 iOffset = (iDbpage-1)*(i64)szPage;
47244 testcase( IS_BIG_INT(iOffset) );
47245 rc = sqlite3OsWrite(pWal->pDbFd, zBuf, szPage, iOffset);
47901 i64 iOffset;
47906 iOffset = walFrameOffset(iRead, sz) + WAL_FRAME_HDRSIZE;
47907 /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL */
47908 return sqlite3OsRead(pWal->pWalFd, pOut, (nOut>sz ? sz : nOut), iOffset);
48154 ** Write iAmt bytes of content into the WAL file beginning at iOffset.
48157 ** In other words, if iSyncPoint is in between iOffset and iOffset+iAmt,
48165 sqlite3_int64 iOffset /* Start writing at this offset */
48168 if( iOffset<p->iSyncPoint && iOffset+iAmt>=p->iSyncPoint ){
48169 int iFirstAmt = (int)(p->iSyncPoint - iOffset);
48170 rc = sqlite3OsWrite(p->pFd, pContent, iFirstAmt, iOffset);
48172 iOffset += iFirstAmt;
48179 rc = sqlite3OsWrite(p->pFd, pContent, iAmt, iOffset);
48190 sqlite3_int64 iOffset /* Byte offset at which to write */
48201 rc = walWriteToLog(p, aFrame, sizeof(aFrame), iOffset);
48204 rc = walWriteToLog(p, pData, p->szPage, iOffset+sizeof(aFrame));
48226 i64 iOffset; /* Next byte to write in WAL file */
48301 iOffset = walFrameOffset(iFrame+1, szPage);
48308 assert( iOffset==walFrameOffset(iFrame, szPage) );
48310 rc = walWriteOneFrame(&w, p, nDbSize, iOffset);
48313 iOffset += szFrame;
48333 w.iSyncPoint = ((iOffset+sectorSize-1)/sectorSize)*sectorSize;
48334 while( iOffset<w.iSyncPoint ){
48335 rc = walWriteOneFrame(&w, pLast, nTruncate, iOffset);
48337 iOffset += szFrame;
71730 int iOffset; /* Byte offset of blob in cursor data */
71778 p->iOffset = v->apCsr[0]->aOffset[p->iCol];
72063 int iOffset,
72076 if( n<0 || iOffset<0 || (iOffset+n)>p->nByte ){
72091 rc = xCall(p->pCsr, iOffset+p->iOffset, n, z);
72109 SQLITE_API int sqlite3_blob_read(sqlite3_blob *pBlob, void *z, int n, int iOffset){
72110 return blobReadWrite(pBlob, z, n, iOffset, sqlite3BtreeData);
72116 SQLITE_API int sqlite3_blob_write(sqlite3_blob *pBlob, const void *z, int n, int iOffset){
72117 return blobReadWrite(pBlob, (void *)z, n, iOffset, sqlite3BtreePutData);
73523 sqlite3_int64 iOffset; /* Offset from the beginning of the file */
73555 assert( iOfst+iAmt<=p->endpoint.iOffset );
73557 if( p->readpoint.iOffset!=iOfst || iOfst==0 ){
73578 p->readpoint.iOffset = iOfst+iAmt;
73600 assert( iOfst==p->endpoint.iOffset );
73605 int iChunkOffset = (int)(p->endpoint.iOffset%JOURNAL_CHUNKSIZE);
73628 p->endpoint.iOffset += iSpace;
73679 *pSize = (sqlite_int64) p->endpoint.iOffset;
76238 pNew->iOffset = 0;
93405 static const u8 iOffset[] = {0, 1, 2, 4, 9, 12, 16};
93414 if( iLength[i]==n && sqlite3StrNICmp(&zText[iOffset[i]],z,n)==0 ){
96515 if( pSelect->iOffset ){
96516 iLimit = pSelect->iOffset+1;
96538 if( p->iOffset && iContinue!=0 ){
96540 sqlite3VdbeAddOp2(v, OP_AddImm, p->iOffset, -1);
96541 addr = sqlite3VdbeAddOp1(v, OP_IfNeg, p->iOffset);
97571 ** Compute the iLimit and iOffset fields of the SELECT based on the
97574 ** keywords. Or NULL if those keywords are omitted. iLimit and iOffset
97577 ** iLimit and iOffset are negative.
97579 ** This routine changes the values of iLimit and iOffset only if
97581 ** iOffset should have been preset to appropriate default values
97591 int iOffset;
97622 p->iOffset = iOffset = ++pParse->nMem;
97624 sqlite3ExprCode(pParse, p->pOffset, iOffset);
97625 sqlite3VdbeAddOp1(v, OP_MustBeInt, iOffset);
97627 addr1 = sqlite3VdbeAddOp1(v, OP_IfPos, iOffset);
97628 sqlite3VdbeAddOp2(v, OP_Integer, 0, iOffset);
97630 sqlite3VdbeAddOp3(v, OP_Add, iLimit, iOffset, iOffset+1);
97633 sqlite3VdbeAddOp2(v, OP_Integer, -1, iOffset+1);
97782 pPrior->iOffset = p->iOffset;
97794 p->iOffset = pPrior->iOffset;
97888 p->iOffset = 0;
98331 int savedOffset; /* Saved value of p->iOffset */
98469 sqlite3VdbeAddOp2(v, OP_Copy, p->iOffset ? p->iOffset+1 : p->iLimit,
98513 savedOffset = p->iOffset;
98515 p->iOffset = 0;
98519 p->iOffset = savedOffset;
126851 int iOffset; /* current position in zInput */
126911 c->iOffset = 0; /* start tokenizing at the beginning */
127391 while( c->iOffset<c->nInput ){
127395 while( c->iOffset<c->nInput && isDelim(z[c->iOffset]) ){
127396 c->iOffset++;
127400 iStartOffset = c->iOffset;
127401 while( c->iOffset<c->nInput && !isDelim(z[c->iOffset]) ){
127402 c->iOffset++;
127405 if( c->iOffset>iStartOffset ){
127406 int n = c->iOffset-iStartOffset;
127417 *piEndOffset = c->iOffset;
127983 int iOffset; /* current position in pInput */
128072 c->iOffset = 0; /* start tokenizing at the beginning */
128108 while( c->iOffset<c->nBytes ){
128112 while( c->iOffset<c->nBytes && simpleDelim(t, p[c->iOffset]) ){
128113 c->iOffset++;
128117 iStartOffset = c->iOffset;
128118 while( c->iOffset<c->nBytes && !simpleDelim(t, p[c->iOffset]) ){
128119 c->iOffset++;
128122 if( c->iOffset>iStartOffset ){
128123 int i, n = c->iOffset-iStartOffset;
128141 *piEndOffset = c->iOffset;