contrib/sqlite3/sqlite3.c

2036 ** [PRAGMA] processing continues.  ^If the [SQLITE_FCNTL_PRAGMA]
5600 ** ^If sqlite3_malloc() fails during the processing of either routine
5730 ** is returned each time a new row of data is ready for processing by the
10180 ** an SQLITE_BUSY error is encountered when processing one or more of the
10183 ** error occurs while processing an attached database, processing is abandoned
10185 ** (SQLITE_BUSY or otherwise) is encountered while processing the attached
10270 ** or continue processing the current SQL statement as appropriate.
10506 ** example an IO error or out-of-memory condition), then processing is
12017 ** returned. Or, if an out-of-memory condition occurs during processing, this
12285 **   when processing a DELETE or UPDATE change if a row with the required
12295 **   argument when processing a DELETE or UPDATE change if a row with the
12303 **   handler while processing an INSERT change if the operation would result
12578 ** an error, all processing is abandoned and the streaming API function
12610 ** it should return some other SQLite error code. In this case processing
17693 ** special handling during INSERT processing. The "OOO" means "Out Of Order".
17802 ** error.  ROLLBACK processing means that a constraint violation
17804 ** to be rolled back.  ABORT processing means the operation in process
17806 ** but the transaction is not rolled back.  FAIL processing means that
18145 ** gives a different answer at different times during statement processing
18360     unsigned done :1;       /* A flag to indicate when processing is finished */
18488 #define WHERE_ORDERBY_MIN      0x0001 /* ORDER BY processing for min() func */
18489 #define WHERE_ORDERBY_MAX      0x0002 /* ORDER BY processing for max() func */
18605   ** information from the INSERT processing down into the UPDATE processing
18607   ** statement and will be freed by INSERT processing. */
19311   u16 eCode;                                /* A small processing code */
22820             case 1: { /* Special processing to add months */
22831             case 2: { /* Special processing to add years */
27320 ** of the sqlite3_initialize() and sqlite3_shutdown() processing, the
53532 ** If an IO error occurs, abandon processing and return the IO error code.
55012           ** processing the journal. This might happen if the journal was
66066 ** This is common tail processing for btreeParseCellPtr() and
71605       ** then the optimistic overflow chain processing in clearCell()
73879   ** happen while processing an "INSERT INTO ... SELECT" statement), it
79181     ** any opcode that does not need processing by virtual of the fact that
80364       ** the P4_SUBPROGRAM processing logic below */
81101     ** but could happen. In this case abandon processing and return the error.
81267 ** This is an internal self-check only - it is not an essential processing
90220     ** loss of information, then special processing is required... */
90601 ** This opcode is used in IN clause processing for a multi-column key.
99412     ** clause processing on UPDATE and DELETE statements, and by
99413     ** UPDATE ... FROM statement processing.
100228   ** sqlite3SelectPrep() do all of the processing for this SELECT.
102680 ** when processing a new CREATE TABLE statement.  A bound parameter raises
102878 ** processing a new CREATE TABLE statement.  When isInit is true, parameters
107739 ** An error occured while parsing or otherwise processing a database
109465 ** if it wants the byte-code to do special processing.
114016   /* Special processing for WITHOUT ROWID Tables */
114856 ** The foreign key is set for IMMEDIATE processing.  A subsequent call
118223     /* Do FK processing. This call checks that any FK constraints that
120820 ** requires any FK processing and, if so, which columns of the original
120821 ** row are required by the FK processing VDBE code (i.e. if FKs were
120827 **   sqlite3FkRequired() - Test to see if FK processing is required.
121567 ** processing for the operation.
121759         ** (when this function is called as part of processing the UPDATE
121822 ** If any foreign key processing will be required, this function returns
121823 ** non-zero. If there is no foreign key related processing, this function
121829 **     and any FK processing at all is required (even of a different FK), or
121834 ** Or, assuming some other foreign key processing is required, 1.
121843   int bHaveFK = 0;                /* If FK processing is required */
121846       /* A DELETE operation. Foreign key processing is required if the
121851       /* This is an UPDATE. Foreign key processing is only required if the
124381           /* If currently processing the PRIMARY KEY of a WITHOUT ROWID
124781 **    *   The same onError processing (OE_Abort, OE_Ignore, etc)
127620 ** remainder of this file is specific to PRAGMA processing.  So omit
131184   int tabTnct;    /* Ephemeral table used for DISTINCT processing */
131523 ** the LEFT OUTER JOIN processing logic that this term is part of the
131526 ** WHERE clause during join processing but we need to remember that they
131529 ** The Expr.iRightJoinTable tells the WHERE clause processing that the
133070     assert( p->op!=TK_AGG_COLUMN );  /* Agg processing has not run yet */
134297 ** following nextX causes a jump to the end of the select processing.
135990   ** SELECT is rewritten for window-functions processing and then passed
136104 ** pParse->pWith linked list).  And if currently processing a CTE
136655 ** Expanding a SELECT statement is the first step in processing a
136741 ** This routine sets up a SELECT statement for processing.  The
137192   SELECTTRACE(1,pParse,p, ("begin processing:\n", pParse->addrExplain));
137370     SELECTTRACE(0x1,pParse,p,("end compound-select processing\n"));
137616   ** used for both the ORDER BY and DISTINCT processing. As originally
137772     NameContext sNC;    /* Name context for processing aggregate information */
137780     int addrEnd;        /* End of processing for this SELECT */
137811         /* The GROUP BY processing doesn't care whether rows are delivered in
137936       /* Initialize memory locations used by GROUP BY aggregate processing
138107       ** the processing calls for the query to abort, this subroutine
138226         ** processing is much simpler since there is only a single row
138311   SELECTTRACE(0x1,pParse,p,("end processing\n"));
140239   int hasFK;             /* True if foreign key processing is required */
140563   /* Jump to labelBreak to abandon further processing of this UPDATE */
140566   /* Not an UPSERT.  Normal processing.  Begin by
141262 ** processing and handling of the Upsert object.
143024 ** processing is abandoned and the error returned to the caller of this
143382   u32 iLikeRepCntr;     /* LIKE range processing counter register (times 2) */
143383   int addrLikeRep;      /* LIKE range processing address */
143471 ** correspond to the subquery(s) of OR-clause processing.  Only the
143590 #define TERM_OR_OK      0x0040 /* Used during OR-clause processing */
143635   WhereInfo *pWInfo;       /* WHERE clause processing context */
143753 ** processing.
143763 ** The WHERE clause processing routine has two halves.  The
144020 ** This function is a no-op unless currently processing an EXPLAIN QUERY PLAN
145876       ** Also, do not do this when processing one index an a multi-index
146133               ** insert the key into the temp table and proceed with processing
147038   WhereInfo *pWInfo = pWC->pWInfo;        /* WHERE clause processing context */
147396   ** inequality constraint (>, <, >= or <=), perform the processing
147709   WhereInfo *pWInfo = pWC->pWInfo; /* WHERE clause processing context */
148161   WhereInfo *pWInfo        /* The WHERE processing context */
148357 ** WHERE clause returns outputs for DISTINCT processing.
148415 ** code an OP_Goto to by pass subsequent processing.
150464 ** processing mode is used only for OR clause processing.
151871       WHERETRACE(0x200, ("Begin processing OR-clause %p\n", pTerm));
151949       WHERETRACE(0x200, ("End processing OR-clause %p\n", pTerm));
152028 ** Note that processing for WHERE_GROUPBY and WHERE_DISTINCTBY is not as
152192           ** doing WHERE_ORDERBY_LIMIT processing).  Except, IS and ISNULL
152969 ** Generate the beginning of the loop used for WHERE clause processing.
152973 ** in order to complete the WHERE clause processing.
153050 ** to use for OR clause processing.  The WHERE clause should use this
153235       /* Try to ORDER BY the result set to make distinct processing easier */
153960 **   in order to support window function processing. For example, with the
153975 **   The flattening optimization is disabled when processing this transformed
154017 **   When processing the rewritten SELECT statement, code in select.c calls
155802 ** for per-row processing is only generated for the following built-in window
156334 ** require slightly different processing. The following pseudo code is
156549 **   2. Instead of processing a single row, each RETURN_ROW, AGGSTEP or
157017 ** Disable all error recovery processing in the parser push-down
157445 **                       defined, then do no error processing.
159301     ** reduce or during error processing or when a parser is
162215       **    processing will occur until three tokens have been
171903   int isFirstTerm = 1;            /* True when processing first term on page */
174808 ** each phrase in the expression (subject to deferred token processing).
177139   ** for processing. This is easy to do, as fts3 has no syntax for escaping
199848     /* Free any SQLite statements used while processing the previous object */
202382 ** input row. Perform whatever processing is required and return.
212665 ** Disable all error recovery processing in the parser push-down
212747 **                       defined, then do no error processing.
213204     ** reduce or during error processing or when a parser is
214008       **    processing will occur until three tokens have been
214921 ** the printf() style processing, then appends the results to buffer pBuf.
223524 ** This function is called whenever processing of the doclist for the
227850     ** processing for a "... MATCH <expr> ORDER BY rank" query (ePlan is