Lines Matching defs:parent
10947 sqlite3_rtree_dbl rParentScore; /* Score of parent node */
10948 int eParentWithin; /* Visibility of parent node */
17889 ** to-table == parent-table
17902 FKey *pNextFrom; /* Next FKey with the same in pFrom. Next parent of pFrom */
18407 ** upwards into parent nodes.
18516 ** not be expanded by "*" in parent queries */
18718 ** NameContext in the parent query. Thus the process of scanning the
22566 ** cell in the parent (calling) frame. When the memory cell is deleted or
22580 VdbeFrame *pParent; /* Parent of this frame, or NULL if parent is main */
22581 Op *aOp; /* Program instructions for parent frame */
22582 i64 *anExec; /* Event counters from parent frame */
22583 Mem *aMem; /* Array of memory cells for parent frame */
22584 VdbeCursor **apCsr; /* Array of Vdbe cursors for parent frame */
22593 int pc; /* Program Counter in parent (calling) frame */
44005 ** the parent directories and then try again.
68191 ** The pointer map is a lookup table that identifies the parent page for
68192 ** each child page in the database file. The parent page is the page that
68194 ** 0 or 1 parent pages. (In this context 'database page' refers
68196 ** entry consists of a single byte 'type' and a 4 byte parent page number.
68201 ** is moved, the pointer in its parent must be updated to point to the
68202 ** new location. The pointer map is used to locate the parent page quickly.
68219 ** identifies the parent page in the btree.
69607 ** so that it maps to type 'eType' and parent page number 'pgno'.
69613 static void ptrmapPut(BtShared *pBt, Pgno key, u8 eType, Pgno parent, int *pRC){
69652 if( eType!=pPtrmap[offset] || get4byte(&pPtrmap[offset+1])!=parent ){
69653 TRACE(("PTRMAP_UPDATE: %d->(%d,%d)\n", key, eType, parent));
69657 put4byte(&pPtrmap[offset+1], parent);
69669 ** the type and parent page number to *pEType and *pPgno respectively.
73889 ** the new child page does not match the flags field of the parent (i.e.
73890 ** if an intkey page appears to be the parent of a non-intkey page, or
73934 ** Move the cursor up to the parent page.
75728 ** only occur when inserting divider cells into the parent page during
76253 ** pParent is its parent. pPage must have a single overflow entry
76277 ** pPage. Make the parent page writable, so that the new divider cell
76310 ** of the parent page are still manipulated by thh code below.
76311 ** That is Ok, at this point the parent page is guaranteed to
76313 ** rollback, undoing any changes made to the parent page.
76404 ** parent page stored in the pointer map is page pTo. If pFrom contained
76406 ** map entries are also updated so that the parent page is page pTo.
76464 ** side if the page is the first or last child of its parent. If the page
76478 ** inserted into or removed from the parent page (pParent). Doing so
76479 ** may cause the parent page to become overfull or underfull. If this
76488 ** buffer big enough to hold one page. If while inserting cells into the parent
76489 ** page (pParent) the parent page becomes overfull, this buffer is
76490 ** used to store the parent's overflow cells. Because this function inserts
76491 ** a maximum of four divider cells into the parent page, and the maximum
76502 u8 *aOvflSpace, /* page-size bytes of space for parent ovfl */
76522 u8 *pRight; /* Location in parent of right-sibling pointer */
76558 ** This loop also drops the divider cells from the parent page. This
76560 ** overflow cells in the parent page, since if any existed they will
76612 /* Drop the cell from the parent page. apDiv[i] still points to
76613 ** the cell within the parent, even though it has been dropped.
76704 ** cells into a parent on a prior balance, and divider cells are always
77201 ** page is the right-child of the parent. Copy the contents of the
77202 ** child page into the parent, decreasing the overall height of the
77211 ** copied into the parent, because if the parent is page 1 then it will
77456 ** will balance the parent page to correct this.
77458 ** If the parent page becomes overfull, the overflow cell or cells
77489 /* The next iteration of the do-loop balances the parent page. */
78730 int iIdx; /* Index of child node in parent */
78743 ** points to the first interior cell that it points to the parent of
78745 ** pCur->aiIdx[pCur->iPage] value is set to the index of the parent cell
78747 ** to visit is the right-child of its parent.
78869 Pgno iParent /* Expected pointer map parent page number */
82973 ** If the bPush flag is true, then make this opcode the parent for
85064 "id", "parent", "notused", "detail"
91486 /* Halt the sub-program. Return control to the parent frame. */
97459 ** of a memory cell in this (the parent) VM that is used to allocate the
97602 ** cell of the calling (parent) frame to cell P2 in the current frames
97606 ** The address of the cell in the parent frame is determined by adding
99470 ** is not necessary to check if it is part of a parent key, as parent
105416 ** as if it were part of the sub-query, not the parent. This block
105528 ** the sub-query back to the parent query. At this point each term
105746 NameContext *pOuterNC /* Name context for parent SELECT statement */
113997 ** parent table. It is passed three arguments:
121040 ** the table referred to (a.k.a the "parent" table). pToCol is a list
121041 ** of tables in the parent pTo table. flags contains all
127177 ** the parent table for a match. If none is found increment the
127180 ** I.2) For each FK for which the table is the parent table,
127182 ** row in the parent table. Decrement the counter for each row
127188 ** search the parent table for a row that corresponds to the
127192 ** D.2) For each FK for which the table is the parent table, search
127194 ** in the parent table. For each found increment the counter.
127268 ** A foreign key constraint requires that the key columns in the parent
127270 ** Given that pParent is the parent table for foreign key constraint pFKey,
127271 ** search the schema for a unique index on the parent key columns.
127273 ** If successful, zero is returned. If the parent key is an INTEGER PRIMARY
127277 ** If the parent key consists of a single column (the foreign key constraint
127280 ** N is the number of columns in the parent key. The first element of the
127282 ** constraint to the parent table column stored in the left-most column
127289 ** 1) The named parent key columns do not exist, or
127291 ** 2) The named parent key columns do exist, but are not subject to a
127294 ** 3) No parent key columns were provided explicitly as part of the
127295 ** foreign key definition, and the parent table does not have a
127298 ** 4) No parent key columns were provided explicitly as part of the
127299 ** foreign key definition, and the PRIMARY KEY of the parent table
127311 Index **ppIdx, /* OUT: Unique index on parent table */
127316 int nCol = pFKey->nCol; /* Number of columns in parent key */
127317 char *zKey = pFKey->aCol[0].zCol; /* Name of left-most parent key column */
127377 i16 iCol = pIdx->aiColumn[i]; /* Index of column in parent tbl */
127426 ** row in the parent table that corresponds to the row being inserted into
127427 ** or deleted from the child table. If the parent row can be found, no
127428 ** special action is taken. Otherwise, if the parent row can *not* be
127429 ** found in the parent table:
127448 Index *pIdx, /* Unique index on parent key columns in pTab */
127450 int *aiCol, /* Map from parent key columns to child table columns */
127458 int iOk = sqlite3VdbeMakeLabel(pParse); /* jump here if parent key found */
127472 ** search for a matching row in the parent table. */
127484 /* If pIdx is NULL, then the parent key is the INTEGER PRIMARY KEY
127485 ** column of the parent table (table pTab). */
127490 ** apply the affinity of the parent key). If this fails, then there
127491 ** is no matching parent key. Before using MustBeInt, make a copy of
127499 /* If the parent table is the same as the child table, and we are about
127526 /* If the parent table is the same as the child table, and we are about
127531 ** If any of the parent-key values are NULL, then the row cannot match
127533 ** of the parent-key values are NULL (at this point it is known that
127547 /* The parent key is a composite key that includes the IPK column */
127645 ** from the parent table of foreign key constraint pFKey and, if pFKey is
127655 ** table that correspond to the parent table row being deleted or inserted.
127674 Table *pTab, /* The parent table */
127675 Index *pIdx, /* Index on parent covering the foreign key */
127701 ** <parent-key1> = <child-key1> AND <parent-key2> = <child-key2> ...
127704 ** the parent key columns. The affinity of the parent key column should
127708 Expr *pLeft; /* Value from parent table row */
127724 /* If the child table is the same as the parent table, then add terms
127732 ** for WITHOUT ROWID tables. In the second form, the *parent* key is
127733 ** (a,b,...). Either the parent or primary key could be used to
127734 ** uniquely identify the current row, but the parent key is more convenient
127740 Expr *pLeft; /* Value from parent table row */
127797 ** NULL pointer (as there are no FK constraints for which t2 is the parent
127850 ** (a) The table is the parent table of a FK constraint, or
127939 ** for which pTab is the parent table. An UPDATE statement against pTab
127947 ** parent key for FK constraint *p are modified.
128053 /* Find the parent table of this foreign key. Also find a unique index
128054 ** on the parent key columns in the parent table. If either of these
128069 ** If the parent table of an FK constraint on the current table is
128099 /* Request permission to read the parent key columns. If the
128101 ** values read from the parent table are NULL. */
128111 /* Take a shared-cache advisory read-lock on the parent table. Allocate
128112 ** a cursor to use to search the unique index on the parent key columns
128113 ** in the parent table. */
128118 /* A row is being removed from the child table. Search for the parent.
128119 ** If the parent does not exist, removing the child row resolves an
128124 /* A row is being added to the child table. If a parent row cannot
128153 /* Inserting a single row into a parent table cannot cause (or fix)
128182 ** removing the parent key will be rectified by the action trigger.
128256 ** * There are any FKs for which pTab is the child and the parent table
128259 ** * the UPDATE modifies one or more parent keys for which the action is
128275 ** table in question is either the child or parent table for any
128280 ** operation modifies one or more child or parent key columns. */
128291 /* Check if any parent key columns are being modified. */
128305 ** compiled on table pTab, which is the parent table of foreign-key pFKey.
128353 int *aiCol = 0; /* child table cols -> parent key cols */
128368 Token tToCol; /* Name of column in parent table */
128383 ** parent table are used for the comparison. */
129954 ** parent table in a foreign key constraint. It is safe to set the
133682 /* 45 */ "parent",
135752 Index *pIdx; /* Index in the parent table */
135761 int *aiCols; /* child to parent column mapping */
135828 /* Generate code to query the parent index for a matching parent
141975 ** position in the parent that NULL-able due to an OUTER JOIN. Either the
141976 ** target slot in the parent is the right operand of a LEFT JOIN, or one of
142408 ** The parent and sub-query may contain WHERE clauses. Subject to
142422 ** ORDER BY clause of the parent must be copies of a term returned
142423 ** by the parent query.
142441 ** parent to a compound query confuses the code that handles
142450 ** (25) If either the subquery or the parent query contains a window
142458 ** is the first element of the parent query. Two subcases:
142478 Select *p, /* The parent or outer SELECT statement */
142669 ** 17 and 18 above) it must be a UNION ALL and the parent query must
142675 ** creates N-1 copies of the parent query without any ORDER BY, LIMIT or
145136 /* This subquery can be absorbed into its parent. */
145237 ** tree referred to by this, the parent select. The child select
147674 /* Code the OP_Program opcode in the parent VDBE. P4 of the OP_Program
152262 ** parent child1 child2
152264 ** Only the parent term was in the original WHERE clause. The child1
152266 ** the virtual child terms are valid, then testing of the parent can be
152269 ** Usually the parent term is marked as TERM_CODED. But if the parent
152270 ** term was originally TERM_LIKE, then the parent gets TERM_LIKECOND instead.
152931 ** the parent context. Do not walk the function arguments in this case.
163172 ** * ORDER BY, LIMIT and OFFSET remain part of the parent query.
163175 ** select-list and ORDER BY expressions in the parent query are
164128 ** redundant, remove the ORDER BY from the parent SELECT. */
187139 Fts3Expr *pParent = p->pParent; /* Current parent of p */
191991 ** now. Instead, the term is inserted into the parent of pTree. If pTree
191992 ** has no parent, one is created here.
192041 ** database. Then call this function recursively to write the parent of
193802 ** into the parent of this node. */
193928 /* Add the current term to the parent node. The term added to the
193929 ** parent must:
193995 ** will be set to 0. If the root node is the parent of the leaves, iRoot
198376 u32 *aUp; /* Index of parent of each node */
200411 "CREATE TABLE x(key,value,type,atom,id,parent,fullkey,path,"
200977 ** an entry in the %_parent table associating the node with its parent.
201181 ** the id is of the parent node and the cell that RtreeSearchPoint
201182 ** represents is the iCell-th entry in the parent node.
201645 RtreeNode *pParent, /* Either the parent node or NULL */
202324 ** in its parent. If pNode is the root node, return -1.
203682 i64 iNode; /* Node number of parent node */
203716 /* Remove the entry in the parent cell. */
203800 ** cell in the parent node so that it tightly contains the updated
204417 "node", "parent", "rowid"
205072 ** the array of coordinates on the parent page that bound the page
205082 u8 *pParent /* Pointer to parent coordinates */
205107 "Dimension %d of cell %d on node %lld is corrupt relative to parent"
205118 ** that bound node iNode on the parent node.
205126 u8 *aParent, /* Buffer containing parent coords */
205298 ** by the parent cell on the parent node.
227664 /* If the child node is now at EOF, so is the parent AND node. Otherwise,
234036 ** copy of (pTerm/nTerm) into the parent node. This is slightly