Lines Matching full:child
4944 ** not possible to open a column that is part of a [child key] for writing.
8825 Table *pFrom; /* Table containing the REFERENCES clause (aka: Child) */
9113 ** the child Expr objects in the Expr.pLeft and Expr.pRight subtrees
17635 int nChildMem; /* Number of memory cells for child frame */
17636 int nChildCsr; /* Number of cursors for child frame */
33043 ** of all of its child journals, one after another, formatted as utf-8
33044 ** encoded text. The end of each child journal file is marked with a
33050 ** A master journal file may only be deleted once all of its child
33054 ** memory and loops through each of the child journal names. For
33055 ** each child journal, it checks if:
33057 ** * if the child journal exists, and if so
33058 ** * if the child journal contains a reference to master journal
33061 ** If a child journal can be found that matches both of the criteria
33063 ** no such child journal can be found, file zMaster is deleted from
33080 sqlite3_file *pJournal; /* Malloc'd child-journal file descriptor */
36934 ** 8 4 Right child (the Ptr(N) value). Omitted on leaves.
36992 ** 4 Page number of the left child. Omitted if leaf flag is set.
37359 ** each child page in the database file. The parent page is the page that
37360 ** contains a pointer to the child. Every page in the database contains
40085 ** 4-byte child pointer
40377 ** PTRMAP_BTREE: pPage is a btree-page. The pointer points at a child
40472 /* If pDbPage was a btree-page, then it may have child pages and/or cells
41738 ** Move the cursor down to a new child page. The newPgno argument is the
41739 ** page number of the child page to move to.
41742 ** the new child page does not match the flags field of the parent (i.e.
41775 ** asserts that page number iChild is the left-child if the iIdx'th
41777 ** cells in pParent, that page number iChild is the right-child of
41797 ** right-most child page then pCur->idx is set to one more than
41822 ** single child page. This can only happen with the table rooted at page 1.
43302 /* Set the right-child pointer of pParent to point to the new page. */
43340 Pgno child = get4byte(z);
43341 ptrmapGet(pBt, child, &e, &n);
43346 Pgno child = get4byte(&pPage->aData[pPage->hdrOffset+8]);
43347 ptrmapGet(pBt, child, &e, &n);
43358 ** the pointer-map entries for each child page are updated so that the
43414 ** This routine redistributes cells on the iParentIdx'th child of pParent
43418 ** side if the page is the first or last child of its parent. If the page
43420 ** is a root page or a child of a root page) then all available siblings
43492 TRACE(("BALANCE: begin page %d child of %d\n", pPage->pgno, pParent->pgno));
43606 ** If the siblings are on leaf pages, then the child pointers of the
43609 ** child pointers. If siblings are not leaves, then all cell in
43610 ** apCell[] include child pointers. Either way, all cells in apCell[]
43653 /* The right pointer of the child page pOld becomes the left
43733 ** page is page 1 and we are the only child of that page.
43910 ** page is the right-child of the parent. Copy the contents of the
43911 ** child page into the parent, decreasing the overall height of the
43919 ** The second assert below verifies that the child page is defragmented
43945 ** 3) If the sibling pages are not leaves, then the child pages of
43953 ** entries for the right-child pages of each sibling may need
43959 ** code only sets pointer map entries for child or overflow pages that have
44006 ** with any child or overflow pages need to be updated. */
44058 ** A new child page is allocated and the contents of the current root
44059 ** page, including overflow cells, are copied into the child. The root
44060 ** page is then overwritten to make it an empty page with the right-child
44064 ** that the new child-page now contains pointers to are updated. The
44065 ** entry corresponding to the new right-child pointer of the root
44068 ** If successful, *ppChild is set to contain a reference to the child
44075 MemPage *pChild = 0; /* Pointer to a new child page */
44076 Pgno pgnoChild = 0; /* Page number of the new child page */
44083 ** page that will become the new right-child of pPage. Copy the contents
44084 ** of the node stored on pRoot into the new child page.
44109 /* Zero the contents of pRoot. Then install pChild as the right-child. */
44143 ** balance_deeper() function to create a new child for the root-page
44145 ** next iteration of the do-loop will balance the child page.
44442 ** sub-tree headed by the child page of the cell being deleted. This makes
44465 ** by the child-page of the cell that was just deleted from an internal
44949 int iIdx; /* Index of child node in parent */
44966 ** to visit is the right-child of its parent.
44985 /* Descend to the child node of the cell that the cursor currently
44986 ** points at. This is the right-child if (iIdx==pPage->nCell).
45068 Pgno iChild, /* Child page number */
45266 /* Check sanity of left child page.
45277 checkAppendMsg(pCheck, zContext, "Child page depth differs");
45286 "On page %d at right child: ", iPage);
45299 /* if we are a left child page */
45301 /* if we are the left most child page */
45321 /* else if we're a right child page */
58442 /* Check that the column is not part of an FK child key definition. It
59204 child nodes. But allow
64729 ** statements corresponding to all child tables of foreign key constraints
72854 ** I.1) For each FK for which the table is the child table, search
72859 ** search the child table for rows that correspond to the new
72865 ** D.1) For each FK for which the table is the child table,
72867 ** deleted row in the child table. If such a row is not found,
72871 ** the child table for rows that correspond to the deleted row
72958 ** array is the index of the child table column that is mapped by the FK
72961 ** child table column that corresponds to the second left-most column of
72977 ** consists of a a different number of columns to the child key in
72978 ** the child table.
73093 ** child table of foreign key constraint pFKey. If an SQL UPDATE is executed
73094 ** on the child table of pFKey, this function is invoked twice for each row
73100 ** or deleted from the child table. If the parent row can be found, no
73123 int *aiCol, /* Map from parent key columns to child table columns */
73124 int regData, /* Address of array containing child table row */
73137 ** Check if any of the key columns in the child table row are NULL. If
73155 /* Invoke MustBeInt to coerce the child key value to an integer (i.e.
73158 ** the value. Otherwise, the value inserted into the child key column
73163 /* If the parent table is the same as the child table, and we are about
73189 /* If the parent table is the same as the child table, and we are about
73239 ** The code generated by this function scans through the rows in the child
73241 ** For each child row found, one of the following actions is taken:
73266 int *aiCol, /* Map from pIdx cols to child table cols */
73286 ** <parent-key1> = <child-key1> AND <parent-key2> = <child-key2> ...
73290 ** be applied to each child key value before the comparison takes place.
73294 Expr *pRight; /* Column ref to child table */
73296 int iCol; /* Index of column in child table */
73297 const char *zCol; /* Name of column in child table */
73323 /* If the child table is the same as the parent table, and this scan
73330 Expr *pRight; /* Column ref to child table */
73416 ** (b) The table is the child table of a deferred FK constraint and it is
73433 ** is the child table. If one cannot be found, return without
73509 ** child table (the table that the foreign key definition is part of). */
73564 /* A row is being removed from the child table. Search for the parent.
73565 ** If the parent does not exist, removing the child row resolves an
73570 /* A row is being added to the child table. If a parent row cannot
73571 ** be found, adding the child row has violated the FK constraint. */
73678 ** table in question is either the child or parent table for any
73683 ** operation modifies one or more child or parent key columns. */
73687 /* Check if any child key columns are being modified. */
73760 char const *zFrom; /* Name of child table */
73763 int *aiCol = 0; /* child table cols -> parent key cols */
73777 Token tFromCol; /* Name of column in child table */
73779 int iFromCol; /* Idx of column in child table */
82867 ** tree refered to by this, the parent select. The child select
86870 #define TERM_COPIED 0x08 /* Has a child */
98333 ** child is "something", and the leftmost term of the right child is
99621 sqlite3_int64 iChild; /* Block id of child node to descend to */
99622 int nBlock; /* Size of child node in bytes */
107748 ** child page.
108101 ** an internal node, then the 64-bit integer is a child page number.
108901 /* Select the child node which will be enlarged the least if pCell
109515 /* Ensure both child nodes have node numbers assigned to them. */
109940 /* Check if the root node now has exactly one child. If so, remove
109941 ** it, schedule the contents of the child for reinsertion and
109944 ** This is equivalent to copying the contents of the child into
