Lines Matching refs:step
2639 ** errors. This step is only necessary if the application desires to keep
4251 ** to step 2. Do this zero or more times.
5201 ** where it always returns zero since each step of that multi-step
7494 ** sorting step is required.
8962 ** step was bypassed because a Bloom filter returned not-found. The
8964 ** times that the Bloom filter returned a find, and thus the join step
14731 ** implementation of an SQL aggregate step callback may not use the
16173 #define OP_AggStep 162 /* synopsis: accum=r[P3] step(r[P2@P5]) */
16174 #define OP_AggStep1 163 /* synopsis: accum=r[P3] step(r[P2@P5]) */
17312 void (*xSFunc)(sqlite3_context*,int,sqlite3_value**); /* func or agg-step */
17315 void (*xInverse)(sqlite3_context*,int,sqlite3_value**); /* inverse agg-step */
19341 ** the first step of the trigger-program.
19381 Trigger *pTrig; /* The trigger that this step is a part of */
19401 TriggerStep retTStep; /* The trigger step */
22945 ** know how to use this object to step through all the values in the
26681 ** of the key chunk. This step usually works if step 1 fails.
26692 ** of the end of the key chunk. This step happens very
35764 /* 162 */ "AggStep" OpHelp("accum=r[P3] step(r[P2@P5])"),
35765 /* 163 */ "AggStep1" OpHelp("accum=r[P3] step(r[P2@P5])"),
43148 ** this step, if a root process opens a database file, it can leave
48313 ** It is not possible to lower the locking level one step at a time. You
52761 ** If NEED_SYNC had been cleared in step 2, then it would not be reset
52762 ** in step 3, and page might be written into the database without first
54527 ** proceed to step 5.
63440 ** for i from 0 to n-1 step 2:
65912 ** This step is important because, even though this connection is holding
72494 ** Perform a single step of an incremental-vacuum. If successful, return
77152 ** step. On the upward pass, both conditions are always true, so the
82140 /* Handle negative integers in a single step. This is needed in the
85554 ** step.
95759 ** thing) is obtained in a two-step algorithm.
97809 ** Synopsis: accum=r[P3] step(r[P2@P5])
97831 ** Synopsis: accum=r[P3] step(r[P2@P5])
97845 ** step function.
97955 ** P2 is the number of arguments that the step function takes and
97960 ** the step function was not previously called.
97967 ** P2 is the number of arguments that the step function takes and
97972 ** the step function was not previously called.
98167 ** Perform a single step of the incremental vacuum procedure on
99971 ** combined into one big PMA in order to be able to step through the sorted
109245 int destStep2; /* Where to jump when NULLs seen in step 2 */
109248 int destNotNull; /* Jump here if a comparison is not true in step 6 */
109249 int addrTop; /* Top of the step-6 loop */
109263 /* Attempt to compute the RHS. After this step, if anything other than
109320 ** This is step (1) in the in-operator.md optimized algorithm.
117154 TriggerStep *pStep /* The trigger step be fixed to one database */
121163 /* Link the foreign key to the table as the last step.
121856 ** step can be skipped.
124520 /* Delete the index and table entries. Skip this step if pTab is really
126424 /* This step function is used for both the min() and max() aggregates,
128354 TriggerStep *pStep = 0; /* First (only) step of trigger program */
128355 Expr *pWhere = 0; /* WHERE clause of trigger step */
128471 sizeof(TriggerStep) + /* Single step in trigger program */
132065 int (*step)(sqlite3_stmt*);
132418 #define sqlite3_step sqlite3_api->step
136039 ** by the OP_IsType code, so it is a required step.
140335 /* If this is an EXPLAIN, skip this step */
144344 ** Expanding a SELECT statement is the first step in processing a
146786 ** a trigger step. Return a pointer to a TriggerStep structure.
146810 ** Allocate space to hold a new trigger step. The allocated space
146842 ** Build a trigger step out of an INSERT statement. Return a pointer
146843 ** to the new trigger step.
146889 ** Construct a trigger step that implements an UPDATE statement and return
146890 ** a pointer to that trigger step. The parser calls this routine when it
146929 ** Construct a trigger step that implements a DELETE statement and return
146930 ** a pointer to that trigger step. The parser calls this routine when it
147318 Trigger *pTrigger, /* The trigger step that defines the RETURNING */
147405 /* Figure out the ON CONFLICT policy that will be used for this step
147409 ** step statement. Example:
148163 int labelContinue; /* Jump here to continue next step of UPDATE loop */
149598 ** step (3) requires additional temporary disk space approximately equal
149602 ** approximately 3 times: Once for step (2) and twice for step (3).
149603 ** Two writes per page are required in step (3) because the original
149608 ** the copy of step (3) were replaced by deleting the original database
153822 ** 1 or more step operations. The question is, how many steps
156660 ** the aggregate-step call to min() or max(), check to see if any
164795 /* All OVER clauses in the same window function aggregate step must
165625 ** step cursor csrEnd forward one row (i.e. sqlite3BtreeNext()).
165629 ** aggregates. Then step cursor csrCurrent forward one row.
165633 ** csrStart. Then step csrStart forward one row.
165792 ** AGGINVERSE step processes the current row of the relevant cursor and
209139 ** A single step of an incremental checkpoint - frame iWalFrame of the wal
210143 /* Figure out the type of table this step will deal with. */
211247 const char *zTbl = pIter->zTbl; /* Table this step applies to */
212556 ** after this step, then rbu_step() again, then a power failure occurs,
219308 ** Find a prepared UPDATE statement suitable for the UPDATE step currently
230051 #define FTS5_OPT_WORK_UNIT 1000 /* Number of leaf pages per optimize step */
234034 ** is if this is the first term written in an incremental-merge step.
234212 ** merge step has finished but the input has not been completely exhausted.