Lines Matching defs:check
263 ** For MinGW, check to see if we can include the header file containing its
283 ** For MinGW version 4.x (and higher), check to see if the _USE_32BIT_TIME_T
448 ** a string which identifies a particular check-in of SQLite
450 ** string contains the date and time of the check-in (UTC) and a SHA1
2091 ** should check the return code from [sqlite3_config()] to make sure that
2473 ** should check the return code from [sqlite3_db_config()] to make sure that
3993 ** that check if a database file was a URI that contained a specific query
6383 ** check the return code and dispose of the application data pointer
8765 ** might be discontinued. Applications should check the return code from
9390 ** sqlite3_backup_finish(). SQLite does not currently check to see
9530 ** One way around this problem is to check the extended error code returned
10941 sqlite3_rtree_dbl *aCoord; /* Coordinates of node or entry to check */
17190 #define SQLITE_IgnoreChecks 0x00000200 /* Do not enforce check constraints */
17948 #define OE_None 0 /* There is no constraint to check */
18714 ** or all contexts are check. When a match is found, the nRef member of
19072 u8 bMaybeNullRow; /* True if we need an OP_IfNullRow check */
19112 u8 checkSchema; /* Causes schema cookie check after an error */
19132 ** of the base register during check-constraint eval */
19453 ** be used on trunk check-ins. They are a temporary mechanism available
19458 #define SQLITE_NTUNE 6 /* Should be zero for all trunk check-ins */
23994 ** already, check for an MSVC build environment that provides
26539 ** size parameters for check-out and return a pointer to the
30115 ** Do the size check before the memory allocation to prevent rogue
31850 /* This only happens when coding check constraints */
37875 ** and check for locks already existing on that inode. When locks are
37924 ** One has to do a run-time check to discover the behavior of the
41218 ** Use F_GETLK to check whether or not there are any readers with open
42950 ** filename, check for the "modeof" parameter. If present, interpret
44332 /* for auto-named local lock file, just check the host ID and we'll
45016 /* Double-check that the aSyscall[] array has been constructed
49843 /* Figure out the effective temporary directory. First, check if one
50078 const char *zFilename, /* Name of file to check */
50519 const char *zFilename, /* Name of file to check */
51220 /* Double-check that the aSyscall[] array has been constructed
52394 /* there was a collision, check to see if it's already */
52402 /* available free spot. check to see if this is going to */
52983 ** The createFlags should be 0 to check for existing pages and should
54196 TESTONLY( nPage = -10; ) /* Disable the pCache->nPage validity check */
55880 ** omits the check for a hot-journal if Pager.eLock is set to UNKNOWN_LOCK
56234 ** was obtained from /dev/random. It is used only as a sanity check.
57003 /* The random check-hash initializer */
58103 ** Open it and check if it points at the super-journal. If
60328 ** check for a hot-journal before reading.
60643 ** This routine does not check if there is a super-journal filename
60709 ** or greater lock on the database file. Now check that there is
60913 /* The shared-lock has just been acquired then check to
61729 ** making changes to a page. The caller must check the return value
63050 sqlite3 *db, /* Db handle used to check for interrupts */
64552 ** thing to check, so only do this occasionally - not on every
64884 ** value of 120, we need to know that so there is an assert() to check it.
65828 /* If the header is read successfully, check the version number to make
66241 /* Now that the read-lock has been obtained, check that neither the
66245 ** It is necessary to check that the wal-index header did not change
66445 ** not, also check that no checkpointer has attempted to checkpoint any
68227 /* A bunch of assert() statements to check the transaction state variables
68254 ** the database. As the integrity-check proceeds, for each page used in
68255 ** the database the corresponding bit is set. This allows integrity-check to
68273 sqlite3 *db; /* Database connection running the check */
68818 ** not loaded, then it is too difficult to actually check to see if
69162 Btree *pBtree, /* The database file to check */
70474 ** pointer in the page header) then check to see if iStart should be
70669 ** of the page, then the page must be corrupted. This check also
70681 ** Do additional sanity check after btreeInitPage() if
73180 ** this lock. The iTable<1 term disables the check for corrupt schemas. */
76898 /* Sanity check: For a non-corrupt database file one of the follwing
77441 ** The purpose of the following assert() is to check that only a
77715 ** So do a complete check.
78843 ** Also check that the page number is in bounds.
78866 IntegrityCk *pCheck, /* Integrity check context */
78940 ** page in this overflow list, check that the pointer-map entry for
79028 IntegrityCk *pCheck, /* Context for the sanity check */
79029 Pgno iPage, /* Page number of the page to check */
79119 /* For leaf pages, the coverage check will occur in the same loop
79285 ** This routine does a complete check of the given BTree file. aRoot[] is
79298 ** root pages is incomplete. This is a "partial integrity-check". This
79299 ** happens when performing an integrity check on a single table. The
79307 sqlite3 *db, /* Database connection that is running the check */
79324 /* aRoot[0]==0 means this is a partial check */
80319 ** no need to check the return values of the btree methods here, as
80589 ** Mem.z = Mem.zMalloc without having to check Mem.flags&MEM_Dyn.
82123 ** check ensures that an EP_TokenOnly expression is never passed down
82890 ** function call. NC_IsCheck means called by a check constraint,
83235 ** Then check that the value of Parse.mayAbort is true if an
84068 ** after an OOM fault without having to check to see if the return from
85553 ** This is an internal self-check only - it is not an essential processing
89642 ** will not bother to check for that condition.
94613 ** SQLite used to check if the root-page flags were sane at this point
94614 ** and report database corruption if they were not, but this check has
95484 ** record are not-NULL then a check is done to determine if any row in the
97307 ** If P5 is not zero, the check is done on the auxiliary database
97313 int nRoot; /* Number of tables to check. (Number of root pages.) */
98287 ** Also, whether or not P4 is set, check that this is not being called from
98781 ** When those function are used in a non-deterministic way, they will check
99461 /* If the value is being opened for writing, check that the
99470 ** is not necessary to check if it is part of a parent key, as parent
99471 ** key columns must be indexed. The check below will pick up this
105443 ** is correlated. It is not required to check the refcount on any
105577 /* If this is part of a compound SELECT, check that it has the right
107689 /* If the RHS is a vector, then we can immediately check to see that
107692 ** we can do the size check, so defer the size check until code generation.
107722 /* Remember the size of the LHS in iTable so that we can check that
107967 ** These routines are Walker callbacks used to check expressions to
108195 ** sequence as the GROUP BY term, but that is much harder to check,
108572 ** whether or not the SELECT result contains NULL values, check whether
109429 ** For a scalar LHS, it is sufficient to check just the first row
109908 ** must check the return code and move the results to the desired
111765 ** This routine is used to check if a LEFT JOIN can be converted into
112622 const char *zTab, /* Table to check for empty */
117125 SrcList *pList /* The Source list to check and modify */
117328 Expr *pExpr, /* The expression to check authorization on */
117378 ** Do an authorization check using the code and arguments given. Return
117911 ** CREATE, then check to see if it is the name of an virtual table that
118279 ** a Table object that was going to be marked ephemeral. So do not check
118505 ** This routine is used to check if the UTF-8 string zName is a legal
118517 const char *zName, /* Name of the object to check */
119383 Expr *pCheckExpr, /* The check expression */
121433 /* If the index name was unqualified, check if the table
121759 ** Either way, check to see if the table already has such an index. If
123225 ** check that it is defined. An undefined collation sequence exists when
125065 ** is essentially a back-out of the bug-fix in check-in [5fc125d362df4b8]
127324 /* If this is a non-composite (single column) foreign key, check if it
127373 ** index matches those columns. Also, check that the index uses
127466 /* If nIncr is less than zero, then check at runtime if there are any
127468 ** to check if deleting this row resolves any outstanding violations.
127501 ** then check if the row being inserted matches itself. If so, do not
127528 ** then check if the row being inserted matches itself. If so, do not
128068 ** before actually dropping it in order to check FK constraints.
129930 /* Generate code to check constraints and generate index keys and
130228 ** This routine also generates code to check constraints. NOT NULL,
130296 int upsertIpkReturn = 0; /* Address of Goto at end of IPK uniqueness check */
130297 int upsertIpkDelay = 0; /* Address of Goto to bypass initial IPK check */
130298 int ipkTop = 0; /* Top of the IPK uniqueness check */
130299 int ipkBottom = 0; /* OP_Goto at the end of the IPK uniqueness check */
130341 Column *pCol = &pTab->aCol[i]; /* The column to check for NOT NULL */
130354 /* Do not check NOT NULL on columns that do not change */
130447 /* The check constraints do not reference any of the columns being
130448 ** updated so there is no point it verifying the check constraint */
130650 && !upsertIpkDelay /* IPK check already deferred by UPSERT */
130667 VdbeNoopComment((v, "uniqueness check for ROWID"));
130769 int addrConflictCk; /* First opcode in the conflict check logic */
130971 int nConflictCk; /* Number of opcodes in conflict check logic */
131009 /* Copy the constraint check code from above, except change
131013 VdbeOp x; /* Conflict check opcode to copy */
131019 int p2; /* New P2 value for copied conflict check opcode */
131460 ** we have to check the semantics.
132752 ** also check to make sure that the pointer to the function is
132891 ** before calling APIs that follow, extension should check the
135029 ** file. Before writing to meta[6], check that meta[3] indicates
135581 /* If there is no index named zRight, check to see if there is a
135897 ** All schemas are checked by default. To check just a single
135938 /* Do an integrity check on each database file */
135951 /* Do an integrity check of the B-Tree
137437 /* If opening a non-empty database, check the text encoding. For the
137763 ** another way to check for early cleanup is to check the return value.
138561 int iStart, /* First member of pSrc->a[] to check */
138562 int iEnd, /* Last member of pSrc->a[] to check */
139051 ** Add code that will check to make sure the array of registers starting at
143286 ** But it is a lot of work to check that case for an obscure and
143697 SrcItem *pFrom /* The FROM clause term to check */
143936 int N /* How many SrcItems to check */
144660 ** Otherwise, return WRC_Prune. In this case, also check if the
144994 /* Clear the SF_UFSrcCheck flag. The check has already been performed,
145890 VdbeComment((v, "check abort flag"));
147938 Index *pIdx, /* The index to check */
147939 int iCol, /* Which column of the index to check */
147968 Index *pIdx, /* The index to check */
148372 ** generated expressions is not used, other than to check to see that it
148756 ** row data. This array is used to check constants, create the new
153069 ** to 0. The OP_Column opcode can check this array to see if the column it
153180 ** index lookup. The idea is that a Bloom filter check is way faster than
153919 /* Except, skip the end-of-range check while doing the NULL-scan */
153933 /* During a NULL-scan, check to see if we have reached the end of
155464 ** will correspond to the common table. We still need to check to make
156660 ** the aggregate-step call to min() or max(), check to see if any
157310 const WhereTerm *pTerm, /* WHERE clause term to check */
157340 const WhereTerm *pTerm, /* WHERE clause term to check */
158088 /* The following assert statements check that the binary search code
159814 ** to check them. But we do need to check any column at 63 or greater.
159864 /* We don't have access to the full query, so we cannot check to see
160906 ExprList *pOrderBy, /* ORDER BY or GROUP BY or DISTINCT clause to check */
160907 WherePath *pPath, /* The WherePath to check */
161073 ** check that it is the only column used by this loop. Otherwise,
164598 ** code to check that the value is a non-negative integer and throws an
166029 ** VM code to check if the input row is the start of a new partition.
173742 /* The following is just a sanity check to make sure SQLite has
174652 ** call will do so. We need to do this before the check for active
186764 /* If this is a "NEAR" keyword, check for an explicit nearness. */
187274 ** 2. It does not check that the expression does not exceed the
187358 /* Rebalance the expression. And check that its depth does not exceed
194842 /* If the hint read from the %_stat table is not empty, check if the
195255 ** Run the integrity-check. If no error occurs and the current contents of
195262 ** The integrity-check works as follows. For each token and indexed token
195277 ** The integrity-check code calculates the same checksum in two ways:
195282 ** If the two checksums are identical, the integrity-check is deemed to have
195314 }else if( nVal==15 && 0==sqlite3_strnicmp(zVal, "integrity-check", 15) ){
196500 /* Now that the shift has been done, check if the initial "..." are
200840 jsonEachEof, /* xEof - check for end of scan */
200868 jsonEachEof, /* xEof - check for end of scan */
201721 /* If no error has occurred so far, check if the "number of entries"
204234 /* If a rowid value was supplied, check if it is already present in
204881 ** implementation of integrity-check function rtreecheck().
205014 ** This function is used to check that the %_parent (if bLeaf==0) or %_rowid
205127 i64 iNode /* Node to check */
205207 ** This function does the bulk of the work for the rtree integrity-check.
205213 const char *zTab, /* Name of rtree table to check */
205216 RtreeCheck check; /* Common context for various routines */
205222 memset(&check, 0, sizeof(check));
205223 check.db = db;
205224 check.zDb = zDb;
205225 check.zTab = zTab;
205228 ** to ensure that the queries run as part of this integrity-check operate
205231 check.rc = sqlite3_exec(db, "BEGIN", 0, 0, 0);
205236 if( check.rc==SQLITE_OK ){
205237 pStmt = rtreeCheckPrepare(&check, "SELECT * FROM %Q.'%q_rowid'", zDb, zTab);
205242 if( check.rc!=SQLITE_NOMEM ){
205243 check.rc = SQLITE_OK;
205248 pStmt = rtreeCheckPrepare(&check, "SELECT * FROM %Q.%Q", zDb, zTab);
205251 check.nDim = (sqlite3_column_count(pStmt) - 1 - nAux) / 2;
205252 if( check.nDim<1 ){
205253 rtreeCheckAppendMsg(&check, "Schema corrupt or not an rtree");
205255 check.bInt = (sqlite3_column_type(pStmt, 1)==SQLITE_INTEGER);
205258 if( rc!=SQLITE_CORRUPT ) check.rc = rc;
205261 /* Do the actual integrity-check */
205262 if( check.nDim>=1 ){
205263 if( check.rc==SQLITE_OK ){
205264 rtreeCheckNode(&check, 0, 0, 1);
205266 rtreeCheckCount(&check, "_rowid", check.nLeaf);
205267 rtreeCheckCount(&check, "_parent", check.nNonLeaf);
205270 /* Finalize SQL statements used by the integrity-check */
205271 sqlite3_finalize(check.pGetNode);
205272 sqlite3_finalize(check.aCheckMapping[0]);
205273 sqlite3_finalize(check.aCheckMapping[1]);
205278 if( check.rc==SQLITE_OK ) check.rc = rc;
205280 *pzReport = check.zReport;
205281 return check.rc;
205290 ** Invoking this SQL function runs an integrity-check on the named rtree
205291 ** table. The integrity-check verifies the following:
206976 /* If a rowid value was supplied, check if it is already present in
212177 ** explicit INTEGER PRIMARY KEY, check that this is not an attempt
213254 ** 3a. If xAccess() is called to check if there exists a *-wal file
213470 ** SQLite will not check for a *-wal file. */
213586 ** check for the existance of a *-wal file. rbuVfsRead() contains
213952 /* If this call is to check if a *-wal file associated with an RBU target
215065 statEof, /* xEof - check for end of scan */
215493 dbpageEof, /* xEof - check for end of scan */
218850 /* If this is an UPDATE that is part of a changeset, then check that
222275 /* Bucket of terms object used by the integrity-check in offsets=0 mode. */
222432 ** Functions called by the storage module as part of integrity-check.
235585 ** for internal sanity checking by the integrity-check in debug
235790 ** Below this point is the implementation of the integrity-check
235817 ** FTS functionality, or even the integrity-check, in any way.
235932 ** FTS functionality, or even the integrity-check, in any way.
235963 /* If this is a prefix query, check that the results returned if the
235966 ** This check may only be performed if the hash table is empty. This
236017 Fts5StructureSegment *pSeg, /* Segment to check internal consistency */
236024 /* Now check that the iter.nEmpty leaves following the current leaf
236088 Fts5StructureSegment *pSeg /* Segment to check internal consistency */
236122 ** to or larger than the split-key in zIdxTerm. Also check that if there
236149 /* Now check that the iter.nEmpty leaves following the current leaf
236156 /* If there is a doclist-index, check that it looks right. */
238378 }else if( 0==sqlite3_stricmp("integrity-check", zCmd) ){
240571 ** Tokenization callback used by integrity check.
244556 stmtEof, /* xEof - check for end of scan */
245619 sqlite3_log(SQLITE_ERROR, "codec: check hmac error at page %d, hmac %d, kdf %d, pageSize %d.",