Lines Matching refs:valid
728 ** is a valid and open [database connection].
1157 /* Methods above are valid for version 1 */
1162 /* Methods above are valid for version 2 */
1165 /* Methods above are valid for version 3 */
1652 ** the string will be valid and unchanged until xClose() is
1717 ** a valid [sqlite3_io_methods] object or to NULL. xOpen must do
1719 ** element will be valid after xOpen returns regardless of the success
1895 ** All other valid calls to sqlite3_shutdown() are harmless no-ops.)^
3298 ** valid memory allocation that has now been freed, then the behavior
3949 ** An error. "readonly" is not a valid option for the "mode" parameter.
4670 ** NULL pointer and is not a pointer to a valid [prepared statement]
4825 ** case, the object and the provided pointer to it must remain valid until
4830 ** object and pointer to it must remain valid until then. ^SQLite will then
5000 ** ^The returned string pointer is valid until either the [prepared statement]
5029 ** ^The returned string is valid until the [prepared statement] is destroyed
5276 ** If the SQL statement does not currently point to a valid row, or if the
5426 ** ^The pointers returned are valid until a type conversion occurs as
6071 ** sqlite3_set_auxdata(C,N,P,X) call if the metadata is still valid or
6719 ** the database connection. ^The value will be valid until the database N
6764 ** a valid schema, then -1 is returned.
7188 ** declaration type and collation sequence is valid until the next
7388 ** ^The registration remains valid until it is replaced by a different
7929 ** is passed a valid open blob handle, the values returned by the
8218 ** of a valid mutex handle. The implementations of the methods defined
8220 ** of passing a NULL pointer instead of a valid mutex handle are undefined
8394 ** These constants are the valid operation code parameters used
8515 ** valid [sqlite3_str] object, though in the event of an out-of-memory
9641 ** that does not correspond to any valid SQLite error code, the results
9718 ** ^(The M parameter must be a valid [checkpoint mode]:)^
9815 ** These constants define all valid values for the "checkpoint mode" passed
10073 ** valid to do so, on the other hand, might cause SQLite to return incorrect
10191 ** The *ppOut values returned by these routines are only valid until the
10233 ** and remains valid for the duration of the xBestIndex method call.
10662 ** of two valid snapshot handles.
10667 ** Additionally, the result of the comparison is only valid if both of the
10697 ** even though the WAL file contains other valid transactions.
10700 ** of database handle db and make all valid snapshots available to
11056 ** created. At present the only valid value for the second parameter is
11489 ** changeset (pChangeset) must remain valid until after the iterator is
11549 ** no error occurs and the iterator points to a valid change after a call
11580 ** valid until either sqlite3changeset_next() is called on the iterator
11621 ** If this function is called when the iterator does not point to a valid
11799 ** WARNING/TODO: This function currently assumes that the input is a valid
12046 ** of passing anything other than a valid function pointer as the xConflict
17235 #define DBFLAG_SchemaKnownOk 0x0010 /* Schema is known to be valid */
18264 ** Expr.flags mask, then Expr.x.pSelect is valid. Otherwise, Expr.x.pList is
18265 ** valid.
18385 #define EP_xIsSelect 0x001000 /* x.pSelect is valid (otherwise x.pList is) */
18553 u8 eU4; /* Which element of a.u4 is valid */
18565 ** is valid.
18612 unsigned isUsing :1; /* u3.pUsing is valid */
18613 unsigned isOn :1; /* u3.pOn was once valid and non-NULL */
18908 ** SRT_Mem Only valid if the result is a single column.
19538 ** the assert is only valid on a well-formed database. Instead of:
20230 #define ONEPASS_SINGLE 1 /* ONEPASS valid for a single row update */
20231 #define ONEPASS_MULTI 2 /* ONEPASS is valid for multiple rows */
22505 /* Cached OP_Column parse information is only valid if cacheStatus matches
22509 u32 cacheStatus; /* Cache is valid if this matches Vdbe.cacheCtr */
22634 void (*xDel)(void*);/* Destructor for Mem.z - only valid if MEM_Dyn */
22708 #define MEM_Subtype 0x0800 /* Mem.eSubtype is valid */
22739 ** Return true if a memory cell has been initialized and is valid.
23576 char validJD; /* True (1) if iJD is valid */
23578 char validYMD; /* True (1) if Y,M,D are valid */
23579 char validHMS; /* True (1) if h,m,s are valid */
23580 char validTZ; /* True (1) if tz is valid */
23855 ** If the value is a valid unix timestamp, put it in p->s and set p->rawS.
25087 /* 0x87f7f is a mask of SQLITE_OPEN_ flags that are valid to be passed
25695 ** Round up a request size to the next valid allocation size.
25967 ** Round up a request size to the next valid allocation size.
26163 assert( pHdr->iForeGuard==FOREGUARD ); /* Allocation is valid */
26185 assert( pHdr->iForeGuard==FOREGUARD ); /* Allocation is valid */
26776 ** Round up a request size to the next valid allocation size.
27221 /* Round nByte up to the next valid power of two */
27279 /* Check that the pointer pOld points to a valid, non-free block. */
27393 ** Round up a request size to the next valid allocation size. If
34014 ** Return TRUE if the result is a valid real number (or integer) and FALSE
34019 ** 0 or less => The input string is not a valid number
34020 ** -1 => Not a valid number, but has a valid prefix which
34032 ** If some prefix of the input string is a valid number, this routine
34935 ** This routine only works if h really is a valid hexadecimal
34985 ** Check to make sure we have a valid db pointer. This test is not
34989 ** 1 it means that the db pointer is valid and 0 if it should not be
34993 ** sqlite3SafetyCheckOk() requires that the db pointer be valid for
36745 (void)gettimeofday(&sNow, 0); /* Cannot fail given valid arguments */
37446 ** is the last system call or if zName is not the name of a valid
38910 ** handles, if they are valid, and sets all fields of the unixFile
38963 /* unixFile.pInode is always valid here. Otherwise, a different close
41075 ** then it isn't valid.*/
42164 ** iOff. The mapping must be valid for at least nAmt bytes.
42582 ** zFilename remains valid until file is closed, to support */
42629 /* NB: zFilename exists and remains valid until the file is closed
42916 int nDb; /* Number of valid bytes in zDb */
43680 (void)gettimeofday(&sNow, 0); /* Cannot fail given valid arguments */
43903 ** which must point to valid, writable memory large enough for a maxLen length
44403 ** valid conch file), try to match the permissions of the database
44771 assert( 0 ); /* The call assures that only valid opcodes are sent */
46298 ** is the last system call or if zName is not the name of a valid
46636 ** Round up a request size to the next valid allocation size.
47679 ** INVALID_SET_FILE_POINTER may also be a valid new offset. So to determine
49576 ** iOff. The mapping must be valid for at least nAmt bytes.
52291 u32 nSet; /* Number of bits that are set - only valid for aHash
52358 ** that can go wrong with an insert, assuming p and i are valid.
52360 ** The calling function must ensure that p is a valid Bitvec object
53660 /* NB: pLruPrev is only valid if pLruNext!=0 */
55168 /* This branch causes a *balanced* tree to be generated. A valid tree
55711 ** * The dbSize, dbOrigSize and dbFileSize variables are all valid.
56044 ** It is valid in PAGER_READER and higher states (all states except for
56061 ** Variables dbOrigSize and dbFileSize are valid in states
56356 /* State must be valid. */
56982 ** rest of the journal file contains valid page records. This assumption
58259 ** (2) 4 byte big-endian integer which is the number of valid page records
58279 ** valid page entries in the journal. In most cases, you can compute the
58558 ** that will never be a valid file version. dbFileVers[] is a copy
58604 ** is valid. */
58796 ** contains no valid committed transactions.
59246 ** * the new page size (value of *pPageSize) is valid (a power
59353 ** less than the total number of valid pages in the database. But this
59354 ** may be less than Pager.dbSize, and so the assert() above is not valid */
59820 ** a valid header following Pager.journalOff, then write a 0x00
60947 ** to be the right size but is not actually valid. Avoid this
62679 ** References to the page pPg remain valid. Updating any
62902 /* The eMode parameter is always valid */
63392 ** used to determine which frames within the WAL are valid and which
63420 ** A frame is considered valid if and only if the following conditions are
63450 ** On a checkpoint, the WAL is first VFS.xSync-ed, then valid content of the
63458 ** being considered valid at the same time and being checkpointing together
63465 ** last valid instance of page P that is a followed by a commit frame
63467 ** contains no copies of page P that are valid and which are a commit
63472 ** valid frame in the WAL. The reader uses this recorded "mxFrame" value
63689 u32 mxFrame; /* Index of last valid frame in the WAL */
64211 ** in aData[] is valid. If it is a valid frame, fill *piPage and
64212 ** *pnTruncate and return true. Return if the frame is not valid.
64226 /* A frame is only valid if the salt values in the frame-header
64233 /* A frame is only valid if the page number is creater than zero.
64240 /* A frame is only valid if a checksum of the WAL header,
64255 /* If we reach this point, the frame is valid. Return the page number
64623 int isValid; /* True if this frame is valid */
64634 ** SQLITE_MAX_PAGE_SIZE, conclude that the WAL file contains no valid
64822 ** to must remain valid for the lifetime of the returned Wal* handle.
64957 u32 iRet = 0xFFFFFFFF; /* 0xffffffff is never a valid page number */
65325 ** The cache of the wal-index header must be valid to call this function.
65568 ** indicate that the log file contains zero valid frames. */
66429 ** of the wal file. Verify that pSnapshot is still valid before
66430 ** continuing. Reasons why pSnapshot might no longer be valid:
67647 ** 92 4 The version-valid-for number
68123 #define BTCF_ValidNKey 0x02 /* True if info.nKey is valid */
68124 #define BTCF_ValidOvfl 0x04 /* True if aOverflow is valid */
68134 ** Cursor does not point to a valid entry. This can happen (for example)
68139 ** Cursor points to a valid entry. getPayload() etc. may be called.
68142 ** Cursor is valid except that the Cursor.skipNext field is non-zero
68197 ** The PTRMAP_XXX identifiers below are the valid types.
69272 ** The cursor passed as the only argument must point to a valid entry
69323 ** The caller must ensure that the cursor is valid (has eState==CURSOR_VALID)
69585 ** Return 0 (not a valid page) for pgno==1 since there is
70080 ** the overflow page that will be valid after pCell has been moved to pPage.
70393 ** validated the freelist. Given that the freelist is valid, there
71826 ** a valid database file.
71841 /* EVIDENCE-OF: R-43737-39999 Every valid SQLite database file begins
72409 ** database. The pDbPage reference remains valid.
72973 ** state of the database. Assume pBt->pPage1 is valid.
73319 ** Make sure the BtCursor* given in the argument has a valid
73320 ** BtCursor.info structure. If it is not already valid, call
73355 ** Return true if the given BtCursor is valid. A valid cursor is one
73370 ** This routine is only valid for a cursor that is pointing into a
73414 ** valid entry. In other words, the calling procedure must guarantee
73664 ** entry for the first required overflow page is valid, skip
73777 ** to a valid row in the table. For sqlite3BtreePayloadChecked(), the
73827 ** returned will not be a valid pointer.
74667 ** opcode, and it that case the cursor will always be valid and
77339 ** Return SQLITE_CORRUPT if any cursor other than pCur is currently valid
77672 ** points to a valid cell.
78065 u8 bPreserve; /* Keep cursor valid. 2 for CURSOR_SKIPNEXT */
79597 ** INTKEY table currently pointing at a valid table entry.
79636 ** (e) the cursor points at a valid row of an intKey table.
80469 ** valid and which are not, so the entire process needs to be restarted.
80735 ** If pMem is an object with a valid string representation, this routine
80792 ** contain a valid string or blob value. */
84069 ** this routine is a valid pointer. But because the dummy.opcode is 0,
84542 ** be valid. Those Mem elements that were not holding auxiliary resources
84594 ** Verify that pFrame is a valid VdbeFrame pointer. Return true if it is
86203 ** Check to ensure that the cursor is valid. Restore the cursor
87288 ** on schemas where the maximum valid header size is 63 bytes or less.
89059 ** Check to see if column iCol of the given statement is valid. If
89061 ** If iCol is not valid, return a pointer to a Mem which has a value
91712 ** previously copied using OP_SCopy, the copies will continue to be valid.
92653 ** The permutation is only valid for the next opcode which must be
92977 ** valid through at least column P3. In other words, there should have been
92978 ** a prior OP_Column for column P3 or greater. If the cursor is not valid,
93296 ** parsed and valid information is in aOffset[] and pC->aType[].
93376 ** all valid.
93993 /* Assert that the p1 parameter is valid. Also that if there is no open
95199 ** If the SeekGE.P1 cursor is not currently pointing to a valid row,
95202 ** If the SeekGE.P1 cursor is pointing to a valid row, then that row
95210 ** cursor ends up pointing at a valid row that is past the target
95222 ** <li> If the cursor is initally not pointed to any valid row, then
95239 ** <li> If the cursor ends up on a valid row that is past the target row
95280 printf("... cursor not valid - fall through\n");
95364 ** P1 must be a valid b-tree cursor.
95803 /* Assert that P3 is a valid memory cell. */
95807 /* Assert that P3 is a valid memory cell. */
95811 /* Assert that P3 is a valid memory cell. */
96226 ** If the P1 cursor must be pointing to a valid row (not a NULL row)
96375 ** if the cursor is valid, then the cursor must already be pointing
96536 ** The Next opcode is only valid following an SeekGT, SeekGE, or
96561 ** The Prev opcode is only valid following an SeekLT, SeekLE, or
99080 ** before their are used, under the (valid) assumption that the registers
99975 ** merged. An aReadr[] object either points to a valid key or else is at EOF.
100259 ** The buffer returned in *ppOut is only valid until the
101857 ** Only INCRINIT_NORMAL is valid in single-threaded builds (when
102885 "argument to %s() is not a valid SQL statement",
102897 ** into the xFilter method. If there is no valid stmt=? constraint,
104467 ** Report an error that an expression is not valid for some set of
106297 ** valid for the life of the returned object. If pVector is a TK_VECTOR
113052 ** point to valid objects, an exception is raised by the memory-checking
113062 ** Technically, as x no longer points into a valid object or to the byte
113063 ** following a valid object, it may not be used in comparison operations.
115114 ** the anEq[] array from pSample->anEq[pSample->iCol+1] onwards are valid.
115138 ** the anEq[] array from pSample->anEq[pSample->iCol] onwards are valid.
123542 ** If nArg is -2, then the first valid function found is returned. A
123543 ** function is valid if xSFunc is non-zero. The nArg==(-2)
123544 ** case is used to see if zName is a valid function name for some number
124418 ** iIdxNoSeek is a valid cursor number (>=0) and is not the same as
124420 ** operation. Or, if iIdxNoSeek is not a valid cursor number, the
124424 ** If iIdxNoSeek is a valid cursor number (>=0) not equal to iDataCur,
126686 ** The expression "a LIKE b ESCAPE c" is only considered a valid LIKE
132311 ** the API. So the redefinition macros are only valid if the
137265 ** No other valid SQL statement, other than the variable CREATE statements,
137791 ** Turn bulk memory into a valid Parse object and link that Parse object
138270 u8 nDefer; /* Number of valid entries in aDefer[] */
138419 ** These are the valid join types:
150727 ** create a valid sqlite3_vtab if it returns SQLITE_OK. */
150740 ** valid to call this function from within the xCreate() or xConnect() of a
151490 u16 n; /* Number of valid a[] entries */
151725 int nRecValid; /* Number of valid fields currently in pRec */
151926 #define WHERE_INDEXED 0x00000200 /* WhereLoop.u.btree.pIndex is valid */
151927 #define WHERE_VIRTUALTABLE 0x00000400 /* WhereLoop.u.vtab is valid */
152266 ** the virtual child terms are valid, then testing of the parent can be
153742 ** point to a valid row for the first iteration of this loop. */
155475 int okToChngToIN = 0; /* True if the conversion to IN is valid */
157938 ** not result in a valid plan.
158740 ** Convert bulk memory into a valid WhereLoop that can be passed
160077 ** (to 2.75) if we have valid STAT4 information for the table.
161009 /* IN terms are only valid for sorting in the ORDER BY LIMIT
161339 int nTo, nFrom; /* Number of valid entries in aTo[] and aFrom[] */
162264 ** a valid cursor number, to avoid an initial
171784 ** to adjust the encoding. The mapping is only valid for alphabetics
174853 ** attempts to use that cursor. Read cursors remain open and valid
175261 if( zFunctionName==0 /* Must have a valid name */
175875 /* EVIDENCE-OF: R-03996-12088 The M parameter must be a valid checkpoint
176669 ** valid input flags for sqlite3_open_v2() are SQLITE_OPEN_READONLY,
177983 ** and query parameters. The pointer returned is valid for use by
179130 ** is responsible for ensuring that the input buffer remains valid
179162 ** implementation. It is only required to be valid until the next call
179579 int mxSavepoint; /* Largest valid xSavepoint integer */
179743 u8 bStart; /* True if iDocid is valid */
184896 ** Fts3Expr.iDocid (valid if bEof==0. The docid of the next row)
186721 unsigned char parenOnly; /* Only valid in paren mode */
190042 ** by the caller. They are valid from the time SegmentReaderNew() returns
190113 int nData; /* Bytes of valid data so far */
190262 ** Return the list of valid segment indexes for absolute level ? */
191644 ** below, the "Fts3HashElem *pE" must be declared so that it is valid
193580 int n; /* Number of valid bytes of data in a[] */
194597 /* Variable iNewStart now contains the first valid leaf node. */
194768 ** not contain at least two valid varints, return SQLITE_CORRUPT_VTAB.
197614 int nNew; /* Number of valid entries in array aNew[] */
198741 ** This routine only works if h really is a valid hexadecimal
199252 ** is no longer valid, parse the JSON again and return the new parse,
201228 u8 bPoint; /* True if sPoint is valid */
201229 u8 bAuxValid; /* True if pReadAux is valid */
202082 ** Return non-zero if the cursor does not currently point to a valid
205726 ** of coordinates. Or, if X is not a valid polygon, return NULL.
206528 ** NULL Either P1 or P2 or both are not valid polygons
206940 int oldRowidValid; /* True if oldRowid is valid */
206942 int newRowidValid; /* True if newRowid is valid */
206970 sqlite3_mprintf("_shape does not contain a valid polygon");
208649 ** The first argument passed to this function must be a valid, open, RBU
208672 ** Database handles returned by this function remain valid until the next
208943 ** Only valid if STAGE==1. The target database name of the table
208947 ** Only valid if STAGE==1. The target database name of the index
208952 ** Only valid if STAGE==1. Number of rows already processed for the current
208974 ** Only valid if STAGE==1. The RBU database name of the table
210681 ** (p->objiter.pSelect) currently points to a valid row. However, there
212078 ** (p->objiter.pSelect) currently points to a valid row. This function
212224 ** The object-iterator (p->objiter) currently points to a valid object,
212225 ** and the input cursor (p->objiter.pSelect) currently points to a valid
214404 /* Look for a valid schema=? constraint. If found, change the idxNum to
216240 ** If, when this function is called, *paTwo points to a valid value (i.e.
216247 ** if( *paTwo is valid ) return *paTwo;
226427 ** FTS5_AND (nChild, apChild valid)
226428 ** FTS5_OR (nChild, apChild valid)
226429 ** FTS5_NOT (nChild, apChild valid)
226430 ** FTS5_STRING (pNear valid)
226431 ** FTS5_TERM (pNear valid)
226902 ** All individual term iterators in pPhrase are guaranteed to be valid and
227391 ** All individual term iterators in pNear are guaranteed to be valid when
227489 ** is valid - each iterator that points to a rowid before iFrom. */
230358 int bPrevValid; /* True if iPrev is valid */
232275 ** no valid values except for the Fts5SegIter.pLeaf member variable. This
232922 int bFrom, /* True if argument iFrom is valid */
233169 ** Iterator pIter currently points to a valid entry (not EOF). This
235899 ** Check if buffer z[], size n bytes, contains as series of valid utf-8
235901 ** contain valid utf-8, return non-zero.
235971 ** Also only do this if buffer zTerm contains nTerm bytes of valid
235973 ** a non-utf-8 sequence that happens to be a prefix of a valid utf-8
239777 int bTotalsValid; /* True if nTotalRow/aTotalSize[] are valid */
240240 ** that the contents of aTotalSize[] and nTotalRow are valid until