Lines Matching defs:pFrom
11028 Table *pFrom; /* Table containing the REFERENCES clause (aka: Child) */
11029 pFrom. Next parent of pFrom */
11038 struct sColMap { /* Mapping of columns in pFrom to columns in zTo */
11039 int iFrom; /* Index of column in pFrom */
18409 sqlite3_mutex_methods const *pFrom;
18413 pFrom = sqlite3DefaultMutex();
18415 pFrom = sqlite3NoopMutex();
18417 memcpy(pTo, pFrom, offsetof(sqlite3_mutex_methods, xMutexAlloc));
18418 memcpy(&pTo->xMutexFree, &pFrom->xMutexFree,
18420 pTo->xMutexAlloc = pFrom->xMutexAlloc;
57570 ** on page pFrom to page pTo. If page pFrom was not a leaf page, then
57572 ** parent page stored in the pointer map is page pTo. If pFrom contained
57576 ** If pFrom is currently carrying any overflow cells (entries in the
57585 static void copyNodeContent(MemPage *pFrom, MemPage *pTo, int *pRC){
57587 BtShared * const pBt = pFrom->pBt;
57588 u8 * const aFrom = pFrom->aData;
57590 int const iFromHdr = pFrom->hdrOffset;
57596 assert( pFrom->isInit );
57597 assert( pFrom->nFree>=iToHdr );
57600 /* Copy the b-tree node content from page pFrom to page pTo. */
57603 memcpy(&aTo[iToHdr], &aFrom[iFromHdr], pFrom->cellOffset + 2*pFrom->nCell);
57608 ** page pFrom.
60789 SQLITE_PRIVATE int sqlite3BtreeCopyFile(Btree *pTo, Btree *pFrom){
60794 sqlite3BtreeEnter(pFrom);
60799 i64 nByte = sqlite3BtreeGetPageSize(pFrom)*(i64)sqlite3BtreeLastPage(pFrom);
60811 b.pSrcDb = pFrom->db;
60812 b.pSrc = pFrom;
60834 sqlite3BtreeLeave(pFrom);
61472 ** Make an shallow copy of pFrom into pTo. Prior contents of
61473 ** pTo are freed. The pFrom->z field is not duplicated. If
61474 ** pFrom->z is used, then pTo->z points to the same thing as pFrom->z
61477 SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int srcType){
61478 assert( (pFrom->flags & MEM_RowSet)==0 );
61480 memcpy(pTo, pFrom, MEMCELLSIZE);
61482 if( (pFrom->flags&MEM_Static)==0 ){
61490 ** Make a full copy of pFrom into pTo. Prior contents of pTo are
61493 SQLITE_PRIVATE int sqlite3VdbeMemCopy(Mem *pTo, const Mem *pFrom){
61496 assert( (pFrom->flags & MEM_RowSet)==0 );
61498 memcpy(pTo, pFrom, MEMCELLSIZE);
61503 if( 0==(pFrom->flags&MEM_Static) ){
61513 ** Transfer the contents of pFrom to pTo. Any existing value in pTo is
61514 ** freed. If pFrom contains ephemeral data, a copy is made.
61516 ** pFrom contains an SQL NULL when this routine returns.
61518 SQLITE_PRIVATE void sqlite3VdbeMemMove(Mem *pTo, Mem *pFrom){
61519 assert( pFrom->db==0 || sqlite3_mutex_held(pFrom->db->mutex) );
61521 assert( pFrom->db==0 || pTo->db==0 || pFrom->db==pTo->db );
61524 memcpy(pTo, pFrom, sizeof(Mem));
61525 pFrom->flags = MEM_Null;
61526 pFrom->xDel = 0;
61527 pFrom->zMalloc = 0;
67526 Vdbe *pFrom = (Vdbe*)pFromStmt;
67529 assert( pTo->db==pFrom->db );
67530 assert( pTo->nVar==pFrom->nVar );
67532 for(i=0; i<pFrom->nVar; i++){
67533 sqlite3VdbeMemMove(&pTo->aVar[i], &pFrom->aVar[i]);
67553 Vdbe *pFrom = (Vdbe*)pFromStmt;
67555 if( pFrom->nVar!=pTo->nVar ){
67561 if( pFrom->isPrepareV2 && pFrom->expmask ){
67562 pFrom->expired = 1;
82887 zWhere = whereOrName(pParse->db, zWhere, p->pFrom->zName);
83173 Table *pFrom = p->pFrom;
83174 if( pFrom!=pTab ){
83175 reloadTableSchema(pParse, p->pFrom, pFrom->zName);
83769 ** Copy the contents of object (*pFrom) into (*pTo).
83772 static void sampleCopy(Stat4Accum *p, Stat4Sample *pTo, Stat4Sample *pFrom){
83773 pTo->isPSample = pFrom->isPSample;
83774 pTo->iCol = pFrom->iCol;
83775 pTo->iHash = pFrom->iHash;
83776 memcpy(pTo->anEq, pFrom->anEq, sizeof(tRowcnt)*p->nCol);
83777 memcpy(pTo->anLt, pFrom->anLt, sizeof(tRowcnt)*p->nCol);
83778 memcpy(pTo->anDLt, pFrom->anDLt, sizeof(tRowcnt)*p->nCol);
83779 if( pFrom->nRowid ){
83780 sampleSetRowid(p->db, pTo, pFrom->nRowid, pFrom->u.aRowid);
83782 sampleSetRowidInt64(p->db, pTo, pFrom->u.iRowid);
88669 pFKey->pFrom = p;
90949 SrcList *pFrom;
90953 pFrom = sqlite3SrcListAppend(db, 0, 0, 0);
90954 if( pFrom ){
90955 assert( pFrom->nSrc==1 );
90956 pFrom->a[0].zName = sqlite3DbStrDup(db, pView->zName);
90957 pFrom->a[0].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zName);
90958 assert( pFrom->a[0].pOn==0 );
90959 assert( pFrom->a[0].pUsing==0 );
90961 pSel = sqlite3SelectNew(pParse, 0, pFrom, pWhere, 0, 0, 0, 0, 0, 0);
93722 pFKey->pFrom->zName, pFKey->zTo);
93810 if( pTab==pFKey->pFrom && nIncr==1 ){
93842 if( pTab==pFKey->pFrom && nIncr==1 ){
94020 zCol = pFKey->pFrom->aCol[iCol].zName;
94037 if( pTab==pFKey->pFrom && nIncr>0 ){
94422 pItem->pTab = pFKey->pFrom;
94423 pItem->zName = pFKey->pFrom->zName;
94590 tFromCol.z = pFKey->pFrom->aCol[iFromCol].zName;
94635 Expr *pDflt = pFKey->pFrom->aCol[iFromCol].pDflt;
94650 zFrom = pFKey->pFrom->zName;
105106 ** pFrom->pIndex and return SQLITE_OK.
105108 SQLITE_PRIVATE int sqlite3IndexedByLookup(Parse *pParse, struct SrcList_item *pFrom){
105109 if( pFrom->pTab && pFrom->zIndex ){
105110 Table *pTab = pFrom->pTab;
105111 char *zIndex = pFrom->zIndex;
105122 pFrom->pIndex = pIdx;
105246 ** This function checks if argument pFrom refers to a CTE declared by
105251 ** If pFrom falls into either of the two categories above, pFrom->pTab
105253 ** (pFrom->pTab!=0) to determine whether or not a successful match
105262 struct SrcList_item *pFrom
105269 assert( pFrom->pTab==0 );
105271 pCte = searchWith(pParse->pWith, pFrom, &pWith);
105289 assert( pFrom->pTab==0 );
105290 pFrom->pTab = pTab = sqlite3DbMallocZero(db, sizeof(Table));
105297 pFrom->pSelect = sqlite3SelectDup(db, pCte->pSelect, 0);
105299 assert( pFrom->pSelect );
105302 pSel = pFrom->pSelect;
105306 SrcList *pSrc = pFrom->pSelect->pSrc;
105415 struct SrcList_item *pFrom;
105440 for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
105442 assert( pFrom->isRecursive==0 || pFrom->pTab );
105443 if( pFrom->isRecursive ) continue;
105444 if( pFrom->pTab!=0 ){
105454 if( withExpand(pWalker, pFrom) ) return WRC_Abort;
105455 if( pFrom->pTab ) {} else
105457 if( pFrom->zName==0 ){
105459 Select *pSel = pFrom->pSelect;
105462 assert( pFrom->pTab==0 );
105464 pFrom->pTab = pTab = sqlite3DbMallocZero(db, sizeof(Table));
105476 assert( pFrom->pTab==0 );
105477 pFrom->pTab = pTab = sqlite3LocateTableItem(pParse, 0, pFrom);
105482 pFrom->pTab = 0;
105490 assert( pFrom->pSelect==0 );
105491 pFrom->pSelect = sqlite3SelectDup(db, pTab->pSelect, 0);
105492 sqlite3WalkSelect(pWalker, pFrom->pSelect);
105498 if( sqlite3IndexedByLookup(pParse, pFrom) ){
105570 for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
105571 Table *pTab = pFrom->pTab;
105572 Select *pSub = pFrom->pSelect;
105573 char *zTabName = pFrom->zAlias;
105612 if( (pFrom->jointype & JT_NATURAL)!=0
105619 if( sqlite3IdListIndex(pFrom->pUsing, zName)>=0 ){
105742 struct SrcList_item *pFrom;
105749 for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
105750 Table *pTab = pFrom->pTab;
105753 Select *pSel = pFrom->pSelect;
107872 ** Parse context structure pFrom has just been used to create a sub-vdbe
107874 ** from pFrom to pTo.
107876 static void transferParseError(Parse *pTo, Parse *pFrom){
107877 assert( pFrom->zErrMsg==0 || pFrom->nErr );
107880 pTo->zErrMsg = pFrom->zErrMsg;
107881 pTo->nErr = pFrom->nErr;
107883 sqlite3DbFree(pFrom->db, pFrom->zErrMsg);
114803 static int whereLoopXfer(sqlite3 *db, WhereLoop *pTo, WhereLoop *pFrom){
114805 if( whereLoopResize(db, pTo, pFrom->nLTerm) ){
114809 memcpy(pTo, pFrom, WHERE_LOOP_XFER_SZ);
114810 memcpy(pTo->aLTerm, pFrom->aLTerm, pTo->nLTerm*sizeof(pTo->aLTerm[0]));
114811 if( pFrom->wsFlags & WHERE_VIRTUALTABLE ){
114812 pFrom->u.vtab.needFree = 0;
114813 }else if( (pFrom->wsFlags & WHERE_AUTO_INDEX)!=0 ){
114814 pFrom->u.btree.pIndex = 0;
116382 WherePath *pFrom; /* An element of aFrom[] that we are working on */
116420 for(ii=mxChoice*2, pFrom=aTo; ii>0; ii--, pFrom++, pX += nLoop){
116421 pFrom->aLoop = pX;
116459 for(ii=0, pFrom=aFrom; ii<nFrom; ii++, pFrom++){
116461 LogEst nOut; /* Rows visited by (pFrom+pWLoop) */
116462 LogEst rCost; /* Cost of path (pFrom+pWLoop) */
116463 LogEst rUnsorted; /* Unsorted cost of (pFrom+pWLoop) */
116464 i8 isOrdered = pFrom->isOrdered; /* isOrdered for (pFrom+pWLoop) */
116468 if( (pWLoop->prereq & ~pFrom->maskLoop)!=0 ) continue;
116469 if( (pWLoop->maskSelf & pFrom->maskLoop)!=0 ) continue;
116472 rUnsorted = sqlite3LogEstAdd(pWLoop->rSetup,pWLoop->rRun + pFrom->nRow);
116473 rUnsorted = sqlite3LogEstAdd(rUnsorted, pFrom->rUnsorted);
116474 nOut = pFrom->nRow + pWLoop->nOut;
116475 maskNew = pFrom->maskLoop | pWLoop->maskSelf;
116478 pWInfo->pOrderBy, pFrom, pWInfo->wctrlFlags,
116481 revMask = pFrom->revLoop;
116529 wherePathName(pFrom, iLoop, pWLoop), rCost, nOut,
116548 wherePathName(pFrom, iLoop, pWLoop), rCost, nOut,
116562 wherePathName(pFrom, iLoop, pWLoop), rCost, nOut,
116580 wherePathName(pFrom, iLoop, pWLoop), rCost, nOut,
116589 pTo->maskLoop = pFrom->maskLoop | pWLoop->maskSelf;
116595 memcpy(pTo->aLoop, pFrom->aLoop, sizeof(WhereLoop*)*iLoop);
116631 pFrom = aTo;
116633 aFrom = pFrom;
116643 /* Find the lowest cost path. pFrom will be left pointing to that path */
116644 pFrom = aFrom;
116646 if( pFrom->rCost>aFrom[ii].rCost ) pFrom = &aFrom[ii];
116652 pLevel->pWLoop = pWLoop = pFrom->aLoop[iLoop];
116662 int rc = wherePathSatisfiesOrderBy(pWInfo, pWInfo->pResultSet, pFrom,
116663 WHERE_DISTINCTBY, nLoop-1, pFrom->aLoop[nLoop-1], ¬Used);
116670 if( pFrom->isOrdered==pWInfo->pOrderBy->nExpr ){
116674 pWInfo->nOBSat = pFrom->isOrdered;
116676 pWInfo->revMask = pFrom->revLoop;
116683 pFrom, 0, nLoop-1, pFrom->aLoop[nLoop-1], ¬Used
116691 pWInfo->nRowOut = pFrom->nRow;
119878 SrcList *pFrom;
119881 pFrom = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&x,pRhs,0,0);
119882 pRhs = sqlite3SelectNew(pParse,0,pFrom,0,0,0,0,0,0,0);
138001 static int fts3SegReaderRequire(Fts3SegReader *pReader, char *pFrom, int nByte){
138004 || (pFrom>=pReader->aNode && pFrom<&pReader->aNode[pReader->nNode])
138007 && (pFrom - pReader->aNode + nByte)>pReader->nPopulate
