Lines Matching defs:count
1259 ** integers where the first integer is the new retry count and the second
2929 ** count, but those made as part of REPLACE constraint resolution are
2983 ** running statement count reaches zero are interrupted as if they had been
2985 ** that are started after the running statement count reaches zero are
3005 ** embedded) and thus do not count as a statement terminator. ^Whitespace
3418 ** "SELECT count(*) FROM tab") then the [SQLITE_READ] authorizer callback
12893 ** SELECT count(*) FROM ftstable;
13310 ** to count the size: 2^31-1 or 2147483647.
13922 ** element pointed to plus the next _ht.count-1 elements in the list.
13932 unsigned int count; /* Number of entries in this table */
13935 unsigned int count; /* Number of entries with this hash */
13981 #define sqliteHashCount(H) ((H)->count)
15565 ** For example, the free-page-count field is located at byte offset 36 of
16109 #define OP_Count 98 /* synopsis: r[P2]=count() */
16605 /* Increment the reference count of an existing page */
17215 /* the count using a callback. */
17253 #define SQLITE_CountOfView 0x00000200 /* The count-of-view optimization */
17299 ** structure. For global built-in functions (ex: substr(), max(), count())
17334 ** count on this object is decremented. When it reaches 0, the destructor
17366 #define SQLITE_FUNC_COUNT 0x0100 /* Built-in count(*) aggregate */
17382 #define SQLITE_FUNC_ANYORDER 0x08000000 /* count/min/max aggregate */
18768 #define NC_OrderAgg 0x8000000 /* Has an aggregate other than count/min/max */
19481 int nLookaside; /* Default lookaside buffer count */
21052 ** It uses the RDTSC opcode to read the cycle count value out of the
21173 ** When testing, keep a count of the number of open files.
22707 #define MEM_Zero 0x0400 /* Mem.i contains count of 0s appended to blob */
23404 pSchema->tblHash.count
23405 + pSchema->trigHash.count
23406 + pSchema->idxHash.count
23407 + pSchema->fkeyHash.count
24897 ** When testing, also keep a count of the number of open files.
29450 ** Add the size of memory allocation "p" to the count in
35343 pNew->count = 0;
35366 pH->count = 0;
35396 pHead = pEntry->count ? pEntry->chain : 0;
35397 pEntry->count++;
35470 unsigned int count; /* Number of elements left to test */
35479 count = pEntry->count;
35483 count = pH->count;
35486 while( count-- ){
35518 assert( pEntry->count>0 );
35519 pEntry->count--;
35522 pH->count--;
35523 if( pH->count==0 ){
35525 assert( pH->count==0 );
35577 pH->count++;
35578 if( pH->count>=10 && pH->count > 2*pH->htsize ){
35579 if( rehash(pH, pH->count*2) ){
35700 /* 98 */ "Count" OpHelp("r[P2]=count()"),
37715 ** a copy of the canonical filename. There is also a reference count.
37798 ** If found, increment the reference count and return a pointer to
37823 ** Decrement the reference count on a vxworksFileId object. Free
37824 ** the object when the reference count reaches zero.
37890 ** a reference count (so we will know when to delete it) and a "cnt"
37905 ** maintains a count of the number of pending locks on tha inode.
37960 ** object keeps a count of the number of unixFile pointing to it.
38871 /* Decrement the count of locks against this same file. When the
38872 ** count reaches zero, close any other file descriptors whose close
41581 /* The reference count on pShmNode has already been incremented under
48367 OSTRACE(("LOCK-PENDING-FAIL file=%p, count=%d, result=%d\n",
48372 OSTRACE(("LOCK-FAIL file=%p, count=%d, rc=%s\n",
49076 /* The reference count on pShmNode has already been incremented under
53143 ** Decrement the reference count on a page. If the page is clean and the
53144 ** reference count drops to 0, then it is made eligible for recycling.
53160 ** Increase the reference count of a supplied page by 1.
53425 ** reference count for all pages.
56942 ** - 4 bytes: Initial database page count.
58805 ** WAL sub-system, determine the page count based on the size of
59340 ** Attempt to set the maximum database page count if mxPage is positive.
59342 ** maximum page count below the current size of the database.
59344 ** Regardless of mxPage, return the current maximum page count.
59746 ** Increment the reference count for page pPg.
60986 ** If the reference count has reached zero, rollback any active
62378 ** current cache hit or miss count, according to the value of eStat. If the
62379 ** reset parameter is non-zero, the cache hit or miss count is zeroed before
68342 ** But we keep a reference count in Btree.wantToLock so the behavior
70244 ** will be ignored if adding the extra space to the fragmentation count
70245 ** causes the fragmentation count to exceed 60.
71681 ** Set the maximum page count for a database if mxPage is positive.
71683 ** Regardless of the value of mxPage, return the maximum page count.
72828 ** transaction count of the shared btree. If the transaction count
74932 /* Decrement the free-list count by 1. Set iTrunk to the index of the
75199 ** its reference count is not altered by this function.
75223 /* Increment the free page count on pPage1 */
75765 /* increment the cell count */
78385 ** freelist count. Hence, the sqlite3BtreeUpdateMeta() call cannot fail.
78838 ** Add 1 to the reference count for page iPage. If this is the second
78922 "freelist leaf count too big on page %d", iPage);
79246 ** that gap is added to the fragmentation count.
84369 ** count of the number of elements to follow */
84636 int nRow; /* Stop when row count reaches this */
85550 ** This routine checks that the sqlite3.nVdbeActive count variable
86754 ** pKey,nKey. The verify that this count is less than or equal to the
91065 u64 start; /* CPU clock count at start of opcode */
91901 ** to returning results such as a row change count or the result of a
93945 ** Synopsis: r[P2]=count()
93950 ** If P3==0, then an exact count is obtained, which involves visiting
95869 ** If the OPFLAG_NCHANGE flag of P5 is set, then the row change count is
96026 ** change count is incremented (otherwise not).
97061 ** If the P3 value is non-zero, then the row change count is incremented
98719 ** Try to set the maximum page count for database P1 to the value in P3.
98720 ** Do not let the maximum page count fall below the current page count and
98721 ** do not change the maximum page count value if P3==0.
98723 ** Store the maximum page count after the change in register P2.
100732 ** to exceed the maximum merge count */
115455 ** If D is the count of distinct values and K is the total number of
115592 u8 needTableCnt = 1; /* True to count the table */
115914 ** name and the row count as the content.
116309 ** zSql1: SELECT idx,count(*) FROM %Q.sqlite_stat4 GROUP BY idx
116444 "SELECT idx,count(*) FROM %Q.sqlite_stat4 GROUP BY idx",
117380 ** is returned, then the error count and error message in pParse are
118329 /* Do not delete the table until the reference count reaches zero. */
123444 ** 4: UTF8/16 conversion required - argument count matches exactly
123445 ** 5: UTF16 byte order conversion required - argument count matches exactly
123446 ** 6: Perfect match: encoding and argument count match exactly.
124148 ** this optimization caused the row change count (the value returned by
124334 int count = (pParse->nested==0); /* True to count changes */
124336 iKey, nKey, count, OE_Default, eOnePass, aiCurOnePass[1]);
124438 u8 count, /* If non-zero, increment the row change counter */
124524 ** If variable 'count' is non-zero, then this OP_Delete instruction should
124533 sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, (count?OPFLAG_NCHANGE:0));
125020 ** of x. If x is text, then we actually count UTF-8 characters.
125021 ** If x is a blob, then we count bytes.
126353 ** count() aggregate function.
126364 ** Routines to implement the count() aggregate function.
126375 ** sure it still operates correctly, verify that its count agrees with our
126376 ** internal count when using count(*) and when the total count can be
127034 WAGGREGATE(count, 0,0,0, countStep,
127037 WAGGREGATE(count, 1,0,0, countStep,
129637 /* Initialize the count of rows to be inserted
129974 /* Update the count of rows that are inserted
130302 int regTrigCnt; /* Register used to count replace trigger invocations */
130576 ** That register will count the number of replace triggers that
130604 VdbeComment((v, "trigger count"));
134592 ** string held in register 3. Decrement the result count in register 1
135119 ** cache_size pages, no spilling occurs until the page count exceeds
135924 /* Set the maximum error count */
136220 sqlite3VdbeAddOp2(v, OP_AddImm, 8+j, 1);/* increment entry count */
137750 ** sqlite3ParseObjectReset(), which reduces the total CPU cycle count.
139053 ** distinct aggregates ("SELECT count(DISTINCT <expr>) ..."). Three strategies
140800 ** than being sent to pDest. The LIMIT count does not begin until after OFFSET
143447 ** SELECT count(*) FROM <tbl>
143453 ** This routine checks to see if it is safe to use the count optimization.
144633 ** count(*) query ("SELECT count(*) FROM pTab").
144774 ** SELECT count(*) FROM (SELECT x FROM t1 UNION ALL SELECT y FROM t2)
144778 ** SELECT (SELECT count(*) FROM t1)+(SELECT count(*) FROM t2)
144785 ** * The outer query is a simple count(*) with no WHERE clause or other
144802 if( sqlite3_stricmp(pExpr->u.zToken,"count") ) return 0; /* Is count() */
144804 if( pExpr->x.pList!=0 ) return 0; /* Must be count(*) */
144851 SELECTTRACE(0x400,pParse,p,("After count-of-view optimization:\n"));
144903 int isAgg; /* True for select lists like "count(*)" */
145085 ** the built-in count(), min(), or max().
145212 ** SELECT count(*) FROM t1; -- SQLITE_READ t1.""
145967 ** SELECT count(*) FROM <tbl>
145991 ** (2013-10-03) Do not count the entries in a partial index.
148183 int regRowCount = 0; /* A count of rows changed */
148504 ** initialize the count of updated rows */
150095 ** Decrement the reference count on a Module object. Destroy the
150096 ** module when the reference count reaches zero.
150136 ** Decrement the ref-count on a virtual table object. When the ref-count
150203 ** list in p->pVTab. It also decrements the VTable ref count. This is
150271 ** The reference count of the VTable structure associated with database
158523 ** Write the estimated row count into *pnRow and return SQLITE_OK.
158587 ** Write the estimated row count into *pnRow and return SQLITE_OK.
161523 /* New path replaces the prior worst to keep count below mxChoice */
162579 ** it is advantageous to reduce the "column count" field in
171570 ** * Set the error count to three.
175089 int count /* Number of times table has been busy */
175103 assert( count>=0 );
175104 if( count < NDELAY ){
175105 delay = delays[count];
175106 prior = totals[count];
175109 prior = totals[NDELAY-1] + delay*(count-(NDELAY-1));
175122 if( (count+1)*1000 > tmout ){
177863 ** u64 *pnSeek // Write seek count here
177868 ** The seek-count is only available if compiled with SQLITE_DEBUG.
179241 int count; /* Number of entries in this table */
179245 int count; /* Number of entries with this hash */
179316 #define fts3HashCount(H) ((H)->count)
184650 int nMinEst = 0; /* The minimum count for any phrase so far. */
184689 ** same phrase and count the number of documents that the merged doclist
185526 ** tokens), count the potential occurrence identified by considering
186080 ** increment the column 0 "nDoc" count for this term.
187680 pNew->count = 0;
187706 pH->count = 0;
187800 pEntry->count++;
187842 int count; /* Number of elements left to test */
187848 count = pEntry->count;
187850 while( count-- && elem ){
187881 pEntry->count--;
187882 if( pEntry->count<=0 ){
187889 pH->count--;
187890 if( pH->count<=0 ){
187892 assert( pH->count==0 );
187970 || (pH->count>=pH->htsize && fts3Rehash(pH, pH->htsize*2))
187972 pH->count = 0;
187989 pH->count++;
190201 /* 14 */ "SELECT count(*) FROM %Q.'%q_segdir' WHERE level = ?",
190223 /* 28 */ "SELECT level, count(*) AS cnt FROM %Q.'%q_segdir' "
191781 int nSuspect, /* Unsorted entry count */
196238 /* Iterate through the phrases in the expression to count them. The same
196538 ** This function is used to count the entries in a column-list (a
196790 int iPosOffset; /* Tokens count up to end of this phrase */
198949 u32 n, /* Content size or sub-node count */
198976 u32 n, /* Content size or sub-node count */
201548 ** Increment the reference count of node p.
201652 ** increase its reference count and return it.
201836 ** count drops to zero, the node data is written to the database.
201948 ** Increment the r-tree reference count.
201955 ** Decrement the r-tree reference count. When the reference count reaches
205155 "Node %lld is too small for cell count of %d (%d bytes)",
205189 pCount = rtreeCheckPrepare(pCheck, "SELECT count(*) FROM %Q.'%q%s'",
205217 sqlite3_stmt *pStmt = 0; /* Used to find column count of rtree table */
209429 /* ERROR: insert count exceeds size of delta */
210002 ** 0) SELECT count(*) FROM sqlite_schema where name=%Q AND IsVirtual(%Q)
210004 ** 2) SELECT count(*) FROM sqlite_schema where name=%Q
211624 "SELECT count(*) FROM stat.sqlite_schema"
212701 sqlite3_mprintf("SELECT count(*) FROM sqlite_schema "
214256 " pageno INTEGER," /* 2 Page number (page count for aggregates) */
221554 ** SELECT count(*) FROM ftstable;
224176 ** * Set the error count to three.
224824 ** Callback used by fts5Bm25GetData() to count the number of rows in the
225076 ** though this byte is not included in the pBuf->n count.
225094 ** included in the pBuf->n count.
230339 int nRef; /* Object reference count */
234757 ** In the first case, return NULL. In the second, increment the ref-count
240536 zSql = sqlite3_mprintf("SELECT count(*) FROM %Q.'%q_%s'",