contrib/sqlite3/sqlite3.c

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;