Lines Matching refs:match
471 ** verify that values returned by these interfaces match the macros in
4024 ** parameter on F or if the value of P does not match any of the
5627 ** nArg parameter is a better match than a function implementation with
5630 ** match than a function where the encoding is different.
5632 ** is a closer match than a function where the encoding difference is
5988 ** last time when the xFinal callback is invoked. ^(When no rows match
8034 ** ^If there is no match, a NULL pointer is returned.
8360 ** ^If the second parameter (zDbName) does not match the name of any
9564 ** Note that this routine returns zero on a match and non-zero if the strings
9565 ** do not match, the same as [sqlite3_stricmp()] and [sqlite3_strnicmp()].
9581 ** insensitive - equivalent upper and lower case ASCII characters match
9587 ** Note that this routine returns zero on a match and non-zero if the strings
9588 ** do not match, the same as [sqlite3_stricmp()] and [sqlite3_strnicmp()].
12066 ** stored in all non-primary key columns also match the values stored in
12111 ** stored in all modified non-primary key columns also match the values
12119 ** to be modified, only those fields need to match the original values to
12808 ** Query for the details of phrase match iIdx within the current row.
13088 ** built-in tokenizers, the FTS5 query 'first + place' will match instances
13090 ** such as "1st place". In some applications, it would be better to match
13168 ** will not match documents that contain the token "1st" (as the tokenizer
13173 ** queries such as 'fi*' or '1s*' will match correctly. However, because
13178 ** a query such as '1s*' will match documents that contain the literal
13181 ** will match against "1st" and "first". This method does not require
15226 ** NOTE: These values must match the corresponding BTREE_ values in btree.h.
15479 ** NOTE: These values must match the corresponding PAGER_ values in
17587 ** Values must match entries in the global constant arrays
18012 ** cause the search to find the last match, or +1 to cause the search to
18013 ** find the first match.
18018 ** before the first match or immediately after the last match. The
18019 ** eqSeen field will indicate whether or not an exact match exists in the
18611 unsigned notCte :1; /* This item may not match a CTE */
18711 ** context is searched first. If no match is found, the next outer
18712 ** context is checked. If there is still no match, the next context
18713 ** is checked. This process continues until either a match is found
18714 ** or all contexts are check. When a match is found, the nRef member of
18715 ** the context containing the match is incremented.
18720 ** subqueries looking for a match.
20925 ** argument match the type set by the previous sqlite3MemdebugSetType().
20929 ** argument match the type set by the previous sqlite3MemdebugSetType().
22360 ** Standard typenames. These names must match the COLTYPE_* definitions.
22513 ** on this cursor" and "the most recent seek was an exact match".
26904 fprintf(out, "%p tail size does not match\n", &mem3.aPool[i]);
35532 ** found, or NULL if there is no match.
37813 /* No match was found. We will make a new file ID */
42215 /* If p!=0, it must match the iOff value. */
43823 ** If the conch file does not exist, or its contents do not match the
44238 /* don't break the lock if the host id doesn't match */
44267 ** lockPath is non-NULL, the host ID and lock file path must match. A NULL
44269 ** host IDs match, or a new lock path will be generated automatically
44352 /* conch host and lock path match */
44357 /* if the conch isn't writable and doesn't match, we can't take it */
44363 /* either the conch didn't match or we need to create a new one */
44403 ** valid conch file), try to match the permissions of the database
44411 /* try to match the database file R/W permissions, ignore failure */
49023 /* TBD need to come up with better match here. Perhaps
49637 /* If p!=0, it must match the iOff value. */
52586 ** match (rc==0). Change rc to non-zero if a discrepancy
56637 ** succeeds, set the Pager.eLock variable to match the (attempted) new lock.
57089 /* Read in the first 8 bytes of the journal header. If they do not match
57151 /* Update the page-size to match the value read from the journal.
57158 /* Update the assumed sector-size to match the value used by
57768 ** and the checksum field does not match the record content.
58124 /* We have a match. Do not delete the super-journal file. */
59923 ** in Pager.dbFileVers[] is updated to match the new value stored in
59985 /* If page 1 was just written, update Pager.dbFileVers to match
61884 ** flushed (as the change-counter values will not match). */
63423 ** (1) The salt-1 and salt-2 values in the frame-header match
63427 ** exactly match the checksum computed consecutively on the
63557 ** prior to finding a match is 1. Each entry of the hash table is an
64227 ** match the salt values in the wal-header.
65566 ** the wal-index header do not match the contents of the
65721 return 1; /* Checksum does not match */
65957 /* Check the salt keys at the start of the wal file still match. */
66782 ** to the start of the log. Update the savepoint values to match.
67938 ** These values must match SQLITE_TXN_NONE, SQLITE_TXN_READ, and
73889 ** the new child page does not match the flags field of the parent (i.e.
74183 ** If an exact match is not found, then the cursor is always
74411 ** If an exact match is not found, then the cursor is always
76438 ** match the new data. The initialization of pTo can actually fail under
79855 ** Attempt to set the page size of the destination to match the page size
82344 ** vector components that match either of the two latter criteria listed
83066 ** through its operation list and change all values of P2 which match
83237 ** match, or false otherwise. This function is intended to be used as
85552 ** currently active. An assertion fails if the two counts do not match.
88914 ** single prepared statement. The iArg values must match.
95359 ** there is known to be at least one match. If the seekHit value is smaller
95457 ** a key P3:N that will match some record in the index. We want to know
95458 ** if it is possible for a record P3:P4 to match some record in the
95460 ** is less than P4, attempt to find out if a match is possible by running
95467 ** to the left is prohibiting a match, and hence there is "no hope" of
95468 ** any match regardless of how many IN clause elements are checked.
95471 ** jump is taken if there is "no hope" of achieving a match.
95486 ** immediately to P2. If there is a match, fall through and leave the P1
97157 ** that match the WHERE clause P4. If P4 is a NULL pointer, then the
103786 ** match anything.
103934 /* Initialize the node to no-match */
103939 ** schema. If not found, pSchema will remain NULL and nothing will match
103968 /* Start at the inner-most context and move outward until a match is found */
104285 ** we have a match (cnt>0) or when we run out of name contexts.
104296 ** Z is a string literal if it doesn't match any column names. In that
104308 /* If a double-quoted identifier does not match any known column name,
104337 ** cnt==0 means there was not match.
104984 ** no match, or if pE is not a simple identifier, then this routine
104992 Expr *pE /* Expression we are trying to match */
105022 ** Attempt to match pE against result set columns in the left-most
105029 ** If there is no match, return 0. Return -1 if an error occurs.
105061 /* Try to match the ORDER BY expression against an expression
105071 /* If no match, return 0. */
105101 ** At the first match, the ORDER BY expression is transformed into
105201 sqlite3ErrorMsg(pParse, "%r ORDER BY term does not match any "
105319 /* If an AS-name match is found, mark this ORDER BY column as being
107690 ** the size of the RHS and LHS match. But if the RHS is a SELECT,
107723 ** the RHS and LHS sizes match during code generation. */
108950 /* If the LHS and RHS of the IN operator do not match, that
109212 ** match the number of columns in the vector on the LHS. If the RHS is
109413 ** an match on the search above, then the result must be FALSE.
114721 ** first two columns match the first two columns of the sample.
117830 /* No match against the official names. But always match "main"
119717 ** match the iCol-th entry of pPk. pPk is always a WITHOUT ROWID
119725 ** collating sequence must match for this routine, but for hasColumn() only
119726 ** the column name must match.
120086 ** the new table will match the result set of the SELECT.
120683 ** being moved. So we cannot stop searching after the first match
120684 ** because the first match might be for one of the deleted indices
121082 "number of columns in foreign key does not match the number of "
121974 ** number of rows in the table that match any particular value of the
121976 ** of rows that match any particular combination of the first 2 columns
123428 ** request is matched. A higher value indicates a better match.
123430 ** If nArg is -1 that means to only return a match (non-zero) if p->nArg
123436 ** match score for any
123440 ** 0: Not a match.
123446 ** 6: Perfect match: encoding and argument count match exactly.
123449 ** a perfect match and any function with xSFunc NULL is
123450 ** a non-match.
123452 #define FUNC_PERFECT_MATCH 6 /* The score for a perfect match */
123454 FuncDef *p, /* The function we are evaluating for match quality */
123458 int match;
123461 /* Wrong number of arguments means "no match" */
123470 match = 4;
123472 match = 1;
123477 match += 2; /* Exact encoding match */
123479 match += 1; /* Both are UTF16, but with different byte orders */
123482 return match;
123487 ** a pointer to the matching FuncDef if found, or 0 if there is no match.
123549 ** match that requested.
123559 FuncDef *pBest = 0; /* Best match found so far */
123560 int bestScore = 0; /* Score of best match */
123568 /* First search for a match amongst the application-defined functions.
123580 /* If no match is found, search the built-in functions.
123607 ** exact match for the name, number of arguments and encoding, then add a
125375 ** SQLITE_NOMATCH: No match
125376 ** SQLITE_NOWILDCARDMATCH: No match in spite of having * or % wildcards.
125392 ** "[a-z]" matches any single lower-case letter. To match a '-', make
125402 ** character, including '%', '_', and esc, match exactly c.
125452 ** first matching character and recursively continue the match from
125538 ** The sqlite3_strglob() interface. Return 0 on a match (like strcmp()) and
125539 ** non-zero if there is no match.
125552 ** The sqlite3_strlike() interface. Return 0 on a match and non-zero for
125965 ** from A by replacing every occurrence of B with C. The match
125981 int loopLimit; /* Last zStr[] that might match zPattern[] */
127177 ** the parent table for a match. If none is found increment the
127531 ** If any of the parent-key values are NULL, then the row cannot match
127768 /* Create VDBE to loop through the entries in pSrc that match the WHERE
131541 /* Default values for second and subsequent columns need to match. */
133643 /* 7 */ "match",
134958 /* If the "=MODE" part does not match any known journal mode,
135829 ** key. If a match is found, jump to addrOk. */
137454 /* If opening an attached database, the encoding much match ENC(db) */
137660 /* Read the schema cookie from the database. If it does not match the
138552 ** The first match found is returned.
139073 ** is compared against previous row. If they match, the new row
142244 ** Expr objects to match newly assigned cursor numbers.
143046 /* A match is found. Add the EP_FixedCol property */
143450 ** does match this pattern, then a pointer to the Table object representing
143690 ** Return 0 if no match is found.
143691 ** Return 1 if a match is found.
143699 Cte *pCte; /* Matched CTE (or NULL if no match) */
143704 /* There are no WITH clauses in the stack. No match is possible */
143865 return 0; /* No match */
145604 ** So set the ASC/DESC flags in the GROUP BY to match those in the
147098 ** if there is no match.
147761 ** 1. The trigger is an exact match to the current DML statement
149008 ** implementation indicates that pWhere may match at most one row.
149377 /* The target contains no match for column jj of the index */
149382 /* Column ii of the index did not match any term of the conflict target.
149396 sqlite3ErrorMsg(pParse, "%sON CONFLICT clause does not match any "
151542 ** quickly for terms that match any of several different operators.
151552 ** If a term in the WHERE clause does not match either of the two previous
151630 char idxaff; /* Must match this affinity, if zCollName!=NULL */
152990 ** SQLite to synthesize a row of NULL values. Which does match the
153314 VdbeComment((v, "init LEFT JOIN no-match flag"));
154203 /* Loop through table entries that match term pOrTerm. */
154309 /* Finish the loop through table entries that match term pOrTerm. */
154537 VdbeComment((v, "match against %s", pTab->zName));
154932 /* A "complete" match if the pattern ends with "*" or "%" */
155039 ** is a match, set *ppLeft to the "column" expression, set *ppRight to the
155043 ** is a match. The usual return is 1, but if the RHS is also a column
155060 { "match", SQLITE_INDEX_CONSTRAINT_MATCH },
155096 /* We can also match against the first column of overloaded
156903 /* Verify the affinity and collating sequence match */
156969 ** first match. Return NULL if there are no matches.
157088 Index *pIdx, /* Index to match column of */
157089 int iCol /* Column of index to match */
157174 ** comparison and select-list expressions must match those of the index.
157408 ** and used to match WHERE clause constraints */
157797 /* 2nd case - a column reference with a COLLATE operator. Only match
158494 ** range query (e.g. col > ?) is assumed to match 1/4 of the rows in the
158496 ** match 1/64 of the index. */
159324 ** index pIndex. Try to match one more.
159465 ** M = the number of rows in the table that match terms to the
160162 ** positioned to the correct row during the right-join no-match
160941 ** (a) All index columns match with WHERE_COLUMN_EQ.
161075 ** considered to match an ORDER BY term.
161188 /* No match found */
161501 /* None of the existing best-so-far paths match the candidate. */
178320 ** is not required for a match.
179674 ** A "phrase" is a sequence of one or more tokens that must match in
179707 int iColumn; /* Index of column this phrase must match */
181478 ** of the %_content table that contains the last match. Return
184385 /* Check if the current entries really are a phrase match */
184512 int iCol; /* The column the token must match */
184909 ** entirely of deferred tokens, it is assumed to match every row in
184914 ** next possible match, considering only non-deferred tokens. In other
184917 ** where "*" may match any single token. The position list in this case
184924 ** really a match, taking into account deferred tokens and NEAR operators.
185058 ** Otherwise, it checks if the current row really does match the NEAR
185062 ** If the current row is a match, the position list associated with each
185066 ** match the current row, 0 is returned. The position lists may or may not
185167 /* If the NEAR expression does not match any rows, zero the doclist for
185253 ** operators and deferred tokens the current row is still a match for the
185259 ** it is determined that the row does *not* match the query.
185261 ** Or, if no error occurs and it seems the current row does match the FTS
185271 ** token. Then, see if this row is really a match, considering deferred
187339 ** column to match against for tokens for which a column name is not explicitly
187341 ** match any table column.
187916 ** found, or NULL if there is no match.
188267 ** match. Not that TRUE is returned even if xCond() fails and
192682 int iCol, /* Column to match on. */
192819 ** Similarly, if this is a search for an exact match, and the first term
192820 ** of segment apSegment[0] is not a match, exit early.
195164 ** Check if the contents of the FTS index match the current contents of the
195165 ** content table. If no error occurs and the contents do match, set *pbOk
195166 ** to true and return SQLITE_OK. Or if the contents do not match, set *pbOk
197074 ** cache does not match the format string for this request, discard
197087 size_t nMatchinfo = 0; /* Number of u32 elements in match-info */
199316 ** a match.
207490 ** 1. uPattern is an unescaped match-all character "%",
207491 ** 2. uPattern is an unescaped match-one character "_",
207610 ** the second is a string to match against that pattern. If either
207666 /* Attempt the match */
209014 ** These values must match the values defined in wal.c for the equivalent
209448 /* ERROR: generated size does not match predicted size */
209743 ** Otherwise, if the only argument does not match the above pattern, an SQL
210636 ** Return an expression that can be used in a WHERE clause to match the
215665 ** Note that the above match the definitions of SQLITE_INTEGER, SQLITE_TEXT
217280 /* Check the table schemas match */
217303 *pzErrMsg = sqlite3_mprintf("table schemas do not match");
219996 ** Otherwise, if there is no primary key match, it is a NOTFOUND. */
221469 ** Query for the details of phrase match iIdx within the current row.
221749 ** built-in tokenizers, the FTS5 query 'first + place' will match instances
221751 ** such as "1st place". In some applications, it would be better to match
221829 ** will not match documents that contain the token "1st" (as the tokenizer
221834 ** queries such as 'fi*' or '1s*' will match correctly. However, because
221839 ** a query such as '1s*' will match documents that contain the literal
221842 ** will match against "1st" and "first". This method does not require
222055 /* If a NEAR() clump or phrase may only match a specific set of columns,
222346 ** Open a new iterator to iterate though all rowids that match the
224306 ** match. See documentation for the highlight() auxiliary function for
226436 int bNomatch; /* True if entry is not a match */
226472 ** within a document for it to match.
226668 ** expression that will match a superset of the rows matched by the LIKE or
226904 ** checks if the current rowid really is a match, and if so populates
226906 ** is set to true if this is really a match, or false otherwise.
226910 ** not a match.
226915 int *pbMatch /* OUT: Set to true if really a match */
227046 ** If no error occurs and non-zero (a match) is returned, the position-list
227095 ** entries that together comprise a match. */
227231 ** phrase is not a match, break out of the loop early. */
227257 ** to match no documents at all, return immediately without initializing any
227751 ** If pNode currently points to a match, this function returns SQLITE_OK
227753 ** to a match or EOF is reached.
227795 ** match. If there are no matches, set the Node.bEof flag to indicate EOF.
227857 ** is not considered an error if the query does not match any documents.
227876 /* If the iterator is not at a real match, skip forward until it is. */
227888 ** is not considered an error if the query does not match any documents.
233311 ** xSetOutputs callback used when the Fts5Colset object has nCol==0 (match
235209 u8 *pToken, /* Buffer containing prefix to match */
235555 ** Open a new iterator to iterate though all rowid that match the
236227 ** checksum does not match. Return SQLITE_OK if all checks pass without
236253 /* Check that the internal nodes of each segment match the leaves */
240638 ** Check that the contents of the FTS index match that of the %_content
240773 ** must match that passed to the sqlite3Fts5StorageStmt() call.
241168 /* Values for eRemoveDiacritic (must match internals of fts5_unicode2.c) */