Lines Matching refs:written
821 ** is not NULL then any error message is written into memory obtained
865 char **errmsg /* Error msg written here */
996 ** information is written to disk in the same order as calls
1136 ** information is written to disk in the same order as calls
2194 int *pnRow, /* Number of result rows written here */
2195 int *pnColumn, /* Number of result columns written here */
2196 char **pzErrmsg /* Error msg written here */
2214 ** the standard C library. The result is written into the
2221 ** characters actually written into the buffer.)^ We admit that
2222 ** the number of characters written would be a more useful return
2230 ** written will be n-1 characters.
2316 ** should neither be read nor written. Even reading previously freed
2620 ** a NULL will be written into *ppDb instead of a pointer to the [sqlite3]
3104 ** content is later written using
4955 ** ^(On success, [SQLITE_OK] is returned and the new [BLOB handle] is written
4971 ** ^(Changes written into a BLOB prior to the BLOB expiring are not
5079 ** [SQLITE_ERROR] is returned and no data is written. ^If N is
5080 ** less than zero [SQLITE_ERROR] is returned and no data is written.
5485 ** *pHighwater is written. ^(Some parameters do not record the highest
5487 ** nothing is written into *pHighwater and the resetFlag is ignored.)^
5489 ** value. For these latter parameters nothing is written into *pCurrent.)^
5499 ** in between the times when *pCurrent and *pHighwater are written.
5529 ** The value written into the *pCurrent parameter is undefined.</dd>)^
5550 ** The value written into the *pCurrent parameter is undefined.</dd>)^
5574 ** The value written into the *pCurrent parameter is undefined.</dd>)^
5604 ** ^The current value of the requested parameter is written into *pCur
5605 ** and the highest instantaneous value is written into *pHiwtr. ^If
5709 ** from, or ready to be written to, the database file. By implementing a
8585 ** collating sequence may not be read or written.
9537 int iMem; /* Base register where results are written */
9813 Parse *pParse; /* The parsing context. Error messages written here */
13154 ** not be read or written.
16313 ** which is the size of the buffer written to.
17751 char *zErrMsg; /* Error message written here */
18831 ** When this routine was originally written it dealt with only
18974 ** of bytes written is returned.
20275 const void *pBuf, /* The bytes to be written */
21364 ** The previous paragraph was written in 2005. (This paragraph is written
22469 ** prior to accessing the inode number. The one byte written is
22672 ** of bytes to be read or written, we give hints to NFS to help it
24277 ** file), the bytes in the locking range should never be read or written. */
24350 ** file), the bytes in the locking range should never be read or written. */
25613 ** (in this case, MAX_PATHNAME bytes). The full-path is written to
25662 ** message is available, it is written to zBufOut. If no error message
26246 ** and written to the conch file.
27813 const void *pBuf, /* The bytes to be written */
28358 ** returns the number of TCHARs written to the output
31297 ** after all dirty pages have been written to the
31353 ** set to 0. If a journal-header is written into the main journal while
31355 ** immediately following the last journal record written into the main
31388 ** if some pages have been appended to the database image but not yet written
31430 ** to wait for a journal sync before they can be written out to
31436 ** (if any) is only written into the journal file once.
31439 ** may be written into the journal file while the pager is still in
31445 ** master journal name is only written to the journal file the first
31456 ** has been written to the journal".
31493 u8 setMaster; /* True if a m-j name has been written to jrnl */
31501 int nRec; /* Pages journalled since last j-header written */
31503 u32 nSubRec; /* Number of records written to sub-journal */
31526 int nRead, nWrite; /* Database pages read/written */
31548 SQLITE_API int sqlite3_pager_writedb_count = 0; /* Number of full pages written to DB */
31549 SQLITE_API int sqlite3_pager_writej_count = 0; /* Number of pages written to journal */
31563 ** written, semi-random garbage data might appear in the journal
31633 ** A page needs to be written into the sub-journal if there exists one
31695 ** This is so that expressions can be written as:
31720 ** a database page may be written atomically, and
31891 ** This function is a no-op if the journal file has not been written to
31945 ** header (JOURNAL_HDR_SZ bytes) is written into the journal file at the
31962 u32 nWrite; /* Bytes of header sector written */
31972 ** since the most recent journal header was written, update the
31985 ** journal header. Normally, zero is written to this value at this time.
32035 ** record is written to the following sector (leaving a gap in the file
32179 ** thing written to a journal file. If the pager is in full-sync mode, the
32181 ** anything is written. The format is:
32217 ** the master journal name. This is in case the previous page written to
32241 ** and 8 bytes of magic data just written to the file. This is
32671 ** thought. If a power failure occurs while the journal is being written,
32672 ** it could cause invalid data to be written into the journal. We need to
32750 /* If this is a rollback of a savepoint and data was not written to
32764 ** requiring a journal-sync before it is written.
32796 ** the PGHDR_NEED_SYNC flag is cleared, if the page is written to
32799 ** be written out into the database file before its journal file
33059 ** failure occurred while the journal was being written, it could be the
33422 ** of the journal header - being written in between the two
33788 ** b) if the page content were written at this time, it would not
33898 ** been written to the journal have actually reached the surface of the
33909 ** then the nRec field of the most recently written journal header
33911 ** been written following it. If the pager is operating in full-sync
33947 ** file happens to be a journal-header (written as part of the
33990 ** is populated with 0xFFFFFFFF when the journal header is written
34036 ** SQLITE_BUSY is returned and no data is written to the database file.
34040 ** written out.
34043 ** the pages are written out to the database file in list order. Writing
34050 ** is updated accordingly. If page 1 is written out, then the value cached
34116 /* If page 1 was just written, update Pager.dbFileVers to match
34244 ** the database image, it may need to be written to the sub-journal.
34258 ** If (X>Y), then when pagerStress is called page X will not be written
34301 ** all information is held in cache. It is never written to disk.
34457 ** + The largest page size that can be written atomically.
34490 ** database is the same as a temp-file that is never written out to
34990 ** to pgno in Pager.pInJournal (bitvec of pages already written to the
35287 ** journal-header is written to the start of it.
35352 ** Mark a single data page as writeable. The page is written into the
35353 ** main journal or sub-journal as required. If the page is written into
35381 /* Mark the page as dirty. If the page has already been written
35390 ** written to the transaction journal or the ckeckpoint journal
35508 ** must have been written to the journal file before returning.
35528 ** header to be written between the pages journaled by this function.
35579 ** before any of them can be written out to the database file.
35622 ** that it does not get written to disk.
35742 ** of a master journal file that should be written into the individual
35750 ** * all dirty pages are written to the database file,
35785 /* If this is an in-memory db, or no pages have been written to, or this
35842 ** being discarded by the truncation must be written to the journal
35877 ** journal file name has already been written to the journal file,
36002 ** In this case there is no chance that the database was written to.
36012 ** In this case the database file may have been written to. So if the
36318 ** pPg refers to will not be written to again within this transaction.
36349 ** If page X were not written to the sub-journal here, it would not
36369 ** be written to, store pPg->pgno in local variable needSyncPgno.
36373 ** can be written to. The caller has already promised not to write to it.
36409 ** sync()ed before any data is written to database file page needSyncPgno.
36417 ** array. Otherwise, if the page is loaded and written again in
36418 ** this transaction, it may be written to the database file before
37208 int nErr; /* Number of messages written to zErrMsg so far */
37669 ** the table corresponding to the index being written, this
37707 ** written. For index b-trees, it is the root page of the associated
38055 ** a free-list leaf page, the page is not written to the database
38061 ** from the database or written to the journal file (why should it
38312 ** a no-op. If an error occurs, the appropriate error code is written
39245 Btree **ppBtree, /* Pointer to new Btree object written here */
39596 ** to insure data is written to the disk surface before
40217 ** can be written to. The caller has already promised not to write to that
40514 ** database are written into the database file and flushed to oxide.
40523 ** the name of a master journal file that should be written into the
40597 ** contents so that they are written onto the disk platter. All this
41113 ** written to *pPgnoNext. If page ovfl is the last page in its linked
41219 ** A total of "amt" bytes are read or written beginning at "offset".
41222 ** The content being read or written might appear on the main page
41270 /* Check if data must be read/written to/from the btree page itself. */
41345 ** range of data that is being read (eOp==0) or written (eOp!=0).
41425 ** skipKey==1. The number of bytes of available key/data is written
41809 ** An integer is written into *pRes which is the result of
41811 ** pointing. The meaning of the integer written into
44680 ** read-only and may not be written.
45588 ** already been written into the pDestDb handle. All that is left
45954 ** copied into the destination database, then the data written to the
46910 ** key is true to get the key or false to get data. The result is written
47031 ** a pointer written to *ppVal. The caller is responsible for deallocating
48781 ** virtual module tables written in this transaction. This has to
48934 ** in case the master journal file name was written into the journal
49682 ** Return the number of bytes written.
49693 ** Return the number of bytes actually written into buf[]. The number
52240 ** If an error occurs, an error message is written to memory obtained
52492 VdbeCursor *pC; /* Cursor to table into which insert is written */
52987 ** The 32-bit integer value P1 is written into register P2.
55782 ** table that cursor P1 points to. The new record number is written
55783 ** written to register P2.
55971 VdbeCursor *pC; /* Cursor to table into which insert is written */
58518 const void *zBuf, /* Take data to be written from here */
58768 const void *zBuf, /* Take data to be written from here */
60611 ** stored in u.zToken. Instead, the integer values is written
61644 ** runtime, then a register is allocated and the register number written
65829 Parse *pParse, /* Error messages will be written here */
67462 ** another error occurs, NULL is returned and an error message written into
67536 ** to the first byte after the last byte written before returning.
68606 int iDb; /* Index of the database that is being written */
70746 /* Delete every item whose key was written to the list during the
74348 ** should be written into a temporary table (template 4). Set to
74349 ** FALSE if each* row of the SELECT can be written directly into
80435 ** The results of the total query are to be written into a destination
82288 ** If anything goes wrong, an error message is written into pParse.
83390 ** The result that is written to ***pazResult is held in memory obtained
84615 ** when the ALTER TABLE is executed and one of the literal values written
85358 ** empty. Only the journal header is written. Apparently it takes more
91507 ** <li> A FILE* to which trace output should be written.
91509 ** <li> A prefix string written at the beginning of every
94096 ** The output of the mkkeywordhash.c program is written into a file
94110 ** might be implemented more directly using a hand-written hash table.
95254 ** I/O active are written using this function. These messages
96437 Btree **ppBtree /* Pointer to new Btree object written here */
97965 ** nodes are written using LeafWriter, and read using LeafReader (to
98010 ** nodes are written using InteriorWriter, and read using
98083 ** written individually (using LeafWriter) to a level 0 segment, with
98092 ** leaf nodes are written in to the %_segments table in order, this
98740 ** The length of data written will be between 1 and FTS3_VARINT_MAX bytes.
98741 ** The number of bytes written is returned.
99397 sqlite3_int64 *piPrev, /* IN/OUT: Previous value written to list */
99485 ** Set *pp to point to the byte just after the last byte written before
99487 ** written (0 if iCol==0).
99490 int n = 0; /* Number of bytes written */
99537 ** after the list written. No terminator (0x00 or 0x01) is written to
99738 ** (size n2 bytes). The output is written to pre-allocated buffer aBuffer,
99740 ** of bytes written to aBuffer is stored in *pnBuffer before returning.
99751 int *pnBuffer, /* OUT: Bytes written to aBuffer */
100131 ** smaller than nList bytes. The code in fts3DoclistMerge() is written
100362 ** rowid should be written to *pRowid.
100527 ** message is written to context pContext and SQLITE_ERROR returned. The
103669 sqlite3_int64 iFirst; /* First slot in %_segments written */
103694 int nEntry; /* Number of terms written to node so far */
104992 ** set to the largest blockid written to the database (or zero if no
104993 ** blocks were written to the db). Otherwise, an SQLite error code is
105002 sqlite3_int64 *piLast, /* OUT: Block id of last entry written */
105127 ** a) be greater than the largest term on the leaf node just written
105211 sqlite3_int64 iLast = 0; /* Largest block id written to database */
105212 sqlite3_int64 iLastLeaf; /* Largest leaf block id written to db */
107507 ** 64 bit integer. The value returned is the number of bytes written
107774 ** count drops to zero, the node data is written to the database.
109865 ** database zDb. If successful, the page-size in bytes is written to