Lines Matching defs:iOffset
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;