lib/sqlite/sqlite3.c

5723 ** from the open BLOB, starting at offset iOffset.)^
5725 ** ^If offset iOffset is less than N bytes from the end of the BLOB,
5726 ** [SQLITE_ERROR] is returned and no data is read.  ^If N or iOffset is
5728 ** ^The size of the blob (and hence the maximum value of N+iOffset)
5744 SQLITE_API int sqlite3_blob_read(sqlite3_blob *, void *Z, int N, int iOffset);
5751 ** into the open BLOB, starting at offset iOffset.
5759 ** ^If offset iOffset is less than N bytes from the end of the BLOB,
5762 ** The size of the BLOB (and hence the maximum value of N+iOffset)
5782 SQLITE_API int sqlite3_blob_write(sqlite3_blob *, const void *z, int n, int iOffset);
10704   int iLimit, iOffset;   /* Memory registers holding LIMIT & OFFSET counters */
16648   int iOffset;       /* An offset into mem5.aCtrl[] */
16679   iOffset = 0;
16682     if( (iOffset+nAlloc)<=mem5.nBlock ){
16683       mem5.aCtrl[iOffset] = ii | CTRL_FREE;
16684       memsys5Link(iOffset, ii);
16685       iOffset += nAlloc;
16687     assert((iOffset+nAlloc)>mem5.nBlock);
32600 ** argument to offset iOffset within the file. If successful, return 0.
32603 static int seekWinFile(winFile *pFile, sqlite3_int64 iOffset){
32608   upperBits = (LONG)((iOffset>>32) & 0x7fffffff);
32609   lowerBits = (LONG)(iOffset & 0xffffffff);
33831         int iOffset = pShmNode->nRegion*szRegion;
33832         int iOffsetShift = iOffset % winSysInfo.dwAllocationGranularity;
33834             0, iOffset - iOffsetShift, szRegion + iOffsetShift
33837                  (int)GetCurrentProcessId(), pShmNode->nRegion, iOffset, szRegion,
33855     int iOffset = iRegion*szRegion;
33856     int iOffsetShift = iOffset % winSysInfo.dwAllocationGranularity;
37982   i64 iOffset;                 /* Starting offset in main journal */
40352     i64 iOffset = (pgno-1)*(i64)pPager->pageSize;
40353     rc = sqlite3OsRead(pPager->fd, pPg->pData, pgsz, iOffset);
40693 **     offset PagerSavepoint.iOffset and continuing to
40754   ** PagerSavepoint.iOffset and continuing to the next journal header.
40762     pPager->journalOff = pSavepoint->iOffset;
43666         aNew[ii].iOffset = pPager->journalOff;
43668         aNew[ii].iOffset = JOURNAL_HDR_SZ(pPager);
45461     i64 iOffset;                  /* Next offset to read from log file */
45520     for(iOffset=WAL_HDRSIZE; (iOffset+szFrame)<=nSize; iOffset+=szFrame){
45526       rc = sqlite3OsRead(pWal->pWalFd, aFrame, szFrame, iOffset);
46092       i64 iOffset;
46095       iOffset = walFrameOffset(iFrame, szPage) + WAL_FRAME_HDRSIZE;
46096       /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL file */
46097       rc = sqlite3OsRead(pWal->pWalFd, zBuf, szPage, iOffset);
46099       iOffset = (iDbpage-1)*(i64)szPage;
46100       testcase( IS_BIG_INT(iOffset) );
46101       rc = sqlite3OsWrite(pWal->pDbFd, zBuf, szPage, iOffset);
46713     i64 iOffset;
46718     iOffset = walFrameOffset(iRead, sz) + WAL_FRAME_HDRSIZE;
46720     /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL */
46721     return sqlite3OsRead(pWal->pWalFd, pOut, nOut, iOffset);
47043     i64 iOffset;                  /* Write offset in log file */
47046     iOffset = walFrameOffset(++iFrame, szPage);
47047     /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL */
47057     rc = sqlite3OsWrite(pWal->pWalFd, aFrame, sizeof(aFrame), iOffset);
47063     rc = sqlite3OsWrite(pWal->pWalFd, pData, szPage, iOffset+sizeof(aFrame));
47073     i64 iOffset = walFrameOffset(iFrame+1, szPage);
47078     iSegment = (((iOffset+iSegment-1)/iSegment) * iSegment);
47079     while( iOffset<iSegment ){
47087       /* testcase( IS_BIG_INT(iOffset) ); // requires a 4GiB WAL */
47088       rc = sqlite3OsWrite(pWal->pWalFd, aFrame, sizeof(aFrame), iOffset);
47092       iOffset += WAL_FRAME_HDRSIZE;
47093       rc = sqlite3OsWrite(pWal->pWalFd, pData, szPage, iOffset);
47098       iOffset += szPage;
69835   int iOffset;            /* Byte offset of blob in cursor data */
69883       p->iOffset = v->apCsr[0]->aOffset[p->iCol];
70168   int iOffset,
70181   if( n<0 || iOffset<0 || (iOffset+n)>p->nByte ){
70196     rc = xCall(p->pCsr, iOffset+p->iOffset, n, z);
70214 SQLITE_API int sqlite3_blob_read(sqlite3_blob *pBlob, void *z, int n, int iOffset){
70215   return blobReadWrite(pBlob, z, n, iOffset, sqlite3BtreeData);
70221 SQLITE_API int sqlite3_blob_write(sqlite3_blob *pBlob, const void *z, int n, int iOffset){
70222   return blobReadWrite(pBlob, (void *)z, n, iOffset, sqlite3BtreePutData);
71454   sqlite3_int64 iOffset;          /* Offset from the beginning of the file */
71486   assert( iOfst+iAmt<=p->endpoint.iOffset );
71488   if( p->readpoint.iOffset!=iOfst || iOfst==0 ){
71509   p->readpoint.iOffset = iOfst+iAmt;
71531   assert( iOfst==p->endpoint.iOffset );
71536     int iChunkOffset = (int)(p->endpoint.iOffset%JOURNAL_CHUNKSIZE);
71559     p->endpoint.iOffset += iSpace;
71610   *pSize = (sqlite_int64) p->endpoint.iOffset;
73977   pNew->iOffset = 0;
89988   static const u8 iOffset[] = {0, 1, 2, 4, 9, 12, 16};
89997     if( iLength[i]==n && sqlite3StrNICmp(&zText[iOffset[i]],z,n)==0 ){
92788     if( pSelect->iOffset ){
92789       iLimit = pSelect->iOffset+1;
92811   if( p->iOffset && iContinue!=0 ){
92813     sqlite3VdbeAddOp2(v, OP_AddImm, p->iOffset, -1);
92814     addr = sqlite3VdbeAddOp1(v, OP_IfNeg, p->iOffset);
93769 ** Compute the iLimit and iOffset fields of the SELECT based on the
93772 ** keywords.  Or NULL if those keywords are omitted. iLimit and iOffset
93775 ** iLimit and iOffset are negative.
93777 ** This routine changes the values of iLimit and iOffset only if
93779 ** iOffset should have been preset to appropriate default values
93789   int iOffset;
93820       p->iOffset = iOffset = ++pParse->nMem;
93822       sqlite3ExprCode(pParse, p->pOffset, iOffset);
93823       sqlite3VdbeAddOp1(v, OP_MustBeInt, iOffset);
93825       addr1 = sqlite3VdbeAddOp1(v, OP_IfPos, iOffset);
93826       sqlite3VdbeAddOp2(v, OP_Integer, 0, iOffset);
93828       sqlite3VdbeAddOp3(v, OP_Add, iLimit, iOffset, iOffset+1);
93831       sqlite3VdbeAddOp2(v, OP_Integer, -1, iOffset+1);
93986       p->iOffset = pPrior->iOffset;
94080       p->iOffset = 0;
94522   int savedOffset;      /* Saved value of p->iOffset */
94658     sqlite3VdbeAddOp2(v, OP_Copy, p->iOffset ? p->iOffset+1 : p->iLimit,
94702   savedOffset = p->iOffset;
94704   p->iOffset = 0;
94708   p->iOffset = savedOffset;
120936   int iOffset;                 /* current position in zInput */
120996   c->iOffset = 0;                 /* start tokenizing at the beginning */
121476   while( c->iOffset<c->nInput ){
121480     while( c->iOffset<c->nInput && isDelim(z[c->iOffset]) ){
121481       c->iOffset++;
121485     iStartOffset = c->iOffset;
121486     while( c->iOffset<c->nInput && !isDelim(z[c->iOffset]) ){
121487       c->iOffset++;
121490     if( c->iOffset>iStartOffset ){
121491       int n = c->iOffset-iStartOffset;
121502       *piEndOffset = c->iOffset;
122068   int iOffset;                 /* current position in pInput */
122157   c->iOffset = 0;                 /* start tokenizing at the beginning */
122193   while( c->iOffset<c->nBytes ){
122197     while( c->iOffset<c->nBytes && simpleDelim(t, p[c->iOffset]) ){
122198       c->iOffset++;
122202     iStartOffset = c->iOffset;
122203     while( c->iOffset<c->nBytes && !simpleDelim(t, p[c->iOffset]) ){
122204       c->iOffset++;
122207     if( c->iOffset>iStartOffset ){
122208       int i, n = c->iOffset-iStartOffset;
122226       *piEndOffset = c->iOffset;