Lines Matching defs:pFrom
18487 Table *pFrom; /* Table containing the REFERENCES clause (aka: Child) */
18488 FKey *pNextFrom; /* Next FKey with the same in pFrom. Next parent of pFrom */
18497 struct sColMap { /* Mapping of columns in pFrom to columns in zTo */
18498 int iFrom; /* Index of column in pFrom */
20003 SrcList *pFrom; /* FROM clause for UPDATE statement (if any) */
21275 SQLITE_PRIVATE void sqlite3RenameTokenRemap(Parse*, const void *pTo, const void *pFrom);
28690 sqlite3_mutex_methods const *pFrom;
28695 pFrom = multiThreadedCheckMutex();
28697 pFrom = sqlite3DefaultMutex();
28700 pFrom = sqlite3NoopMutex();
28702 pTo->xMutexInit = pFrom->xMutexInit;
28703 pTo->xMutexEnd = pFrom->xMutexEnd;
28704 pTo->xMutexFree = pFrom->xMutexFree;
28705 pTo->xMutexEnter = pFrom->xMutexEnter;
28706 pTo->xMutexTry = pFrom->xMutexTry;
28707 pTo->xMutexLeave = pFrom->xMutexLeave;
28708 pTo->xMutexHeld = pFrom->xMutexHeld;
28709 pTo->xMutexNotheld = pFrom->xMutexNotheld;
28711 pTo->xMutexAlloc = pFrom->xMutexAlloc;
78157 ** on page pFrom to page pTo. If page pFrom was not a leaf page, then
78159 ** parent page stored in the pointer map is page pTo. If pFrom contained
78163 ** If pFrom is currently carrying any overflow cells (entries in the
78172 static void copyNodeContent(MemPage *pFrom, MemPage *pTo, int *pRC){
78174 BtShared * const pBt = pFrom->pBt;
78175 u8 * const aFrom = pFrom->aData;
78177 int const iFromHdr = pFrom->hdrOffset;
78183 assert( pFrom->isInit );
78184 assert( pFrom->nFree>=iToHdr );
78187 /* Copy the b-tree node content from page pFrom to page pTo. */
78190 memcpy(&aTo[iToHdr], &aFrom[iFromHdr], pFrom->cellOffset + 2*pFrom->nCell);
78195 ** page pFrom.
82290 SQLITE_PRIVATE int sqlite3BtreeCopyFile(Btree *pTo, Btree *pFrom){
82295 sqlite3BtreeEnter(pFrom);
82300 i64 nByte = sqlite3BtreeGetPageSize(pFrom)*(i64)sqlite3BtreeLastPage(pFrom);
82312 b.pSrcDb = pFrom->db;
82313 b.pSrc = pFrom;
82335 sqlite3BtreeLeave(pFrom);
83411 ** Make an shallow copy of pFrom into pTo. Prior contents of
83412 ** pTo are freed. The pFrom->z field is not duplicated. If
83413 ** pFrom->z is used, then pTo->z points to the same thing as pFrom->z
83416 static SQLITE_NOINLINE void vdbeClrCopy(Mem *pTo, const Mem *pFrom, int eType){
83419 sqlite3VdbeMemShallowCopy(pTo, pFrom, eType);
83421 SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int srcType){
83422 assert( !sqlite3VdbeMemIsRowSet(pFrom) );
83423 assert( pTo->db==pFrom->db );
83424 if( VdbeMemDynamic(pTo) ){ vdbeClrCopy(pTo,pFrom,srcType); return; }
83425 memcpy(pTo, pFrom, MEMCELLSIZE);
83426 if( (pFrom->flags&MEM_Static)==0 ){
83434 ** Make a full copy of pFrom into pTo. Prior contents of pTo are
83437 SQLITE_PRIVATE int sqlite3VdbeMemCopy(Mem *pTo, const Mem *pFrom){
83440 assert( !sqlite3VdbeMemIsRowSet(pFrom) );
83442 memcpy(pTo, pFrom, MEMCELLSIZE);
83445 if( 0==(pFrom->flags&MEM_Static) ){
83455 ** Transfer the contents of pFrom to pTo. Any existing value in pTo is
83456 ** freed. If pFrom contains ephemeral data, a copy is made.
83458 ** pFrom contains an SQL NULL when this routine returns.
83460 SQLITE_PRIVATE void sqlite3VdbeMemMove(Mem *pTo, Mem *pFrom){
83461 assert( pFrom->db==0 || sqlite3_mutex_held(pFrom->db->mutex) );
83463 assert( pFrom->db==0 || pTo->db==0 || pFrom->db==pTo->db );
83466 memcpy(pTo, pFrom, sizeof(Mem));
83467 pFrom->flags = MEM_Null;
83468 pFrom->szMalloc = 0;
91786 Vdbe *pFrom = (Vdbe*)pFromStmt;
91789 assert( pTo->db==pFrom->db );
91790 assert( pTo->nVar==pFrom->nVar );
91792 for(i=0; i<pFrom->nVar; i++){
91793 sqlite3VdbeMemMove(&pTo->aVar[i], &pFrom->aVar[i]);
91813 Vdbe *pFrom = (Vdbe*)pFromStmt;
91815 if( pFrom->nVar!=pTo->nVar ){
91822 assert( (pFrom->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || pFrom->expmask==0 );
91823 if( pFrom->expmask ){
91824 pFrom->expired = 1;
116208 ** with parse tree element pFrom. This function remaps the associated token
116211 SQLITE_PRIVATE void sqlite3RenameTokenRemap(Parse *pParse, const void *pTo, const void *pFrom){
116215 if( p->p==pFrom ){
116775 if( pStep->pFrom ){
116777 for(i=0; i<pStep->pFrom->nSrc && rc==SQLITE_OK; i++){
116778 SrcItem *p = &pStep->pFrom->a[i];
116846 if( pStep->pFrom ){
116848 for(i=0; i<pStep->pFrom->nSrc; i++){
116849 sqlite3WalkSelect(pWalker, pStep->pFrom->a[i].pSelect);
117237 if( pStep->pFrom ){
117239 for(i=0; i<pStep->pFrom->nSrc; i++){
117240 SrcItem *pItem = &pStep->pFrom->a[i];
118063 ** Copy the contents of object (*pFrom) into (*pTo).
118066 static void sampleCopy(StatAccum *p, StatSample *pTo, StatSample *pFrom){
118067 pTo->isPSample = pFrom->isPSample;
118068 pTo->iCol = pFrom->iCol;
118069 pTo->iHash = pFrom->iHash;
118070 memcpy(pTo->anEq, pFrom->anEq, sizeof(tRowcnt)*p->nCol);
118071 memcpy(pTo->anLt, pFrom->anLt, sizeof(tRowcnt)*p->nCol);
118072 memcpy(pTo->anDLt, pFrom->anDLt, sizeof(tRowcnt)*p->nCol);
118073 if( pFrom->nRowid ){
118074 sampleSetRowid(p->db, pTo, pFrom->nRowid, pFrom->u.aRowid);
118076 sampleSetRowidInt64(p->db, pTo, pFrom->u.iRowid);
120320 || sqlite3FixSrcList(pFix, pStep->pFrom)
124262 pFKey->pFrom = p;
127017 SrcList *pFrom;
127021 pFrom = sqlite3SrcListAppend(pParse, 0, 0, 0);
127022 if( pFrom ){
127023 assert( pFrom->nSrc==1 );
127024 pFrom->a[0].zName = sqlite3DbStrDup(db, pView->zName);
127025 pFrom->a[0].zDatabase = sqlite3DbStrDup(db, db->aDb[iDb].zDbSName);
127026 assert( pFrom->a[0].fg.isUsing==0 );
127027 assert( pFrom->a[0].u3.pOn==0 );
127029 pSel = sqlite3SelectNew(pParse, 0, pFrom, pWhere, 0, 0, pOrderBy,
130939 pFKey->pFrom->zName, pFKey->zTo);
131009 int iReg = sqlite3TableColumnToStorage(pFKey->pFrom,aiCol[i]) + regData + 1;
131026 sqlite3TableColumnToStorage(pFKey->pFrom,aiCol[0])+1+regData, regTemp);
131034 if( pTab==pFKey->pFrom && nIncr==1 ){
131053 sqlite3TableColumnToStorage(pFKey->pFrom, aiCol[i])+1+regData,
131067 if( pTab==pFKey->pFrom && nIncr==1 ){
131070 int iChild = sqlite3TableColumnToStorage(pFKey->pFrom,aiCol[i])
131249 zCol = pFKey->pFrom->aCol[iCol].zCnName;
131269 if( pTab==pFKey->pFrom && nIncr>0 ){
131610 iReg = sqlite3TableColumnToStorage(pFKey->pFrom,iFromCol) + regOld+1;
131701 pItem->pTab = pFKey->pFrom;
131702 pItem->zName = pFKey->pFrom->zName;
131917 sqlite3TokenInit(&tFromCol, pFKey->pFrom->aCol[iFromCol].zCnName);
131955 Column *pCol = pFKey->pFrom->aCol + iFromCol;
131962 pDflt = sqlite3ColumnExpr(pFKey->pFrom, pCol);
131978 zFrom = pFKey->pFrom->zName;
147243 ** pFrom->pIndex and return SQLITE_OK.
147245 SQLITE_PRIVATE int sqlite3IndexedByLookup(Parse *pParse, SrcItem *pFrom){
147246 Table *pTab = pFrom->pTab;
147247 char *zIndexedBy = pFrom->u1.zIndexedBy;
147250 assert( pFrom->fg.isIndexedBy!=0 );
147261 assert( pFrom->fg.isCte==0 );
147262 pFrom->u2.pIBIndex = pIdx;
147348 ** Check to see if the FROM clause term pFrom has table-valued function
147350 ** non-zero, since pFrom is not allowed to be a table-valued function.
147352 static int cannotBeFunction(Parse *pParse, SrcItem *pFrom){
147353 if( pFrom->fg.isTabFunc ){
147354 sqlite3ErrorMsg(pParse, "'%s' is not a function", pFrom->zName);
147427 ** This function checks if argument pFrom refers to a CTE declared by
147433 ** If pFrom matches a CTE according to either of these two above, pFrom->pTab
147443 SrcItem *pFrom /* The FROM clause term to check */
147448 assert( pFrom->pTab==0 );
147458 if( pFrom->zDatabase!=0 ){
147463 if( pFrom->fg.notCte ){
147471 pCte = searchWith(pParse->pWith, pFrom, &pWith);
147492 if( cannotBeFunction(pParse, pFrom) ) return 2;
147494 assert( pFrom->pTab==0 );
147508 pFrom->pTab = pTab;
147514 pFrom->pSelect = sqlite3SelectDup(db, pCte->pSelect, 0);
147516 pFrom->pSelect->selFlags |= SF_CopyCte;
147517 assert( pFrom->pSelect );
147518 if( pFrom->fg.isIndexedBy ){
147519 sqlite3ErrorMsg(pParse, "no such index: \"%s\"", pFrom->u1.zIndexedBy);
147522 pFrom->fg.isCte = 1;
147523 pFrom->u2.pCteUse = pCteUse;
147527 pRecTerm = pSel = pFrom->pSelect;
147640 SQLITE_PRIVATE int sqlite3ExpandSubquery(Parse *pParse, SrcItem *pFrom){
147641 Select *pSel = pFrom->pSelect;
147645 pFrom->pTab = pTab = sqlite3DbMallocZero(pParse->db, sizeof(Table));
147648 if( pFrom->zAlias ){
147649 pTab->zName = sqlite3DbStrDup(pParse->db, pFrom->zAlias);
147651 pTab->zName = sqlite3MPrintf(pParse->db, "%!S", pFrom);
147721 SrcItem *pFrom;
147761 for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
147763 assert( pFrom->fg.isRecursive==0 || pFrom->pTab!=0 );
147764 if( pFrom->pTab ) continue;
147765 assert( pFrom->fg.isRecursive==0 );
147766 if( pFrom->zName==0 ){
147768 Select *pSel = pFrom->pSelect;
147771 assert( pFrom->pTab==0 );
147773 if( sqlite3ExpandSubquery(pParse, pFrom) ) return WRC_Abort;
147776 }else if( (rc = resolveFromTermToCte(pParse, pWalker, pFrom))!=0 ){
147778 pTab = pFrom->pTab;
147783 assert( pFrom->pTab==0 );
147784 pFrom->pTab = pTab = sqlite3LocateTableItem(pParse, 0, pFrom);
147789 pFrom->pTab = 0;
147793 if( !IsVirtual(pTab) && cannotBeFunction(pParse, pFrom) ){
147801 assert( pFrom->pSelect==0 );
147809 pFrom->pSelect = sqlite3SelectDup(db, pTab->u.view.pSelect, 0);
147813 && pFrom->fg.fromDDL
147825 sqlite3WalkSelect(pWalker, pFrom->pSelect);
147833 if( pFrom->fg.isIndexedBy && sqlite3IndexedByLookup(pParse, pFrom) ){
147910 for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
147912 Table *pTab = pFrom->pTab; /* Table for this data source */
147917 IdList *pUsing; /* USING clause for pFrom[1] */
147919 if( (zTabName = pFrom->zAlias)==0 ){
147923 assert( (int)pFrom->fg.isNestedFrom == IsNestedFrom(pFrom->pSelect) );
147924 if( pFrom->fg.isNestedFrom ){
147925 assert( pFrom->pSelect!=0 );
147926 pNestedFrom = pFrom->pSelect->pEList;
147939 && pFrom[1].fg.isUsing
147943 pUsing = pFrom[1].u3.pUsing;
148005 if( pFrom->fg.isUsing
148006 && sqlite3IdListIndex(pFrom->u3.pUsing, zName)>=0
148015 && ( (pFrom->fg.jointype & JT_LTORJ)==0
148017 || !inAnyUsingClause(zName,pFrom,pTabList->nSrc-i-1)
148052 if( (pFrom->fg.isUsing
148053 && sqlite3IdListIndex(pFrom->u3.pUsing, zName)>=0)
148155 SrcItem *pFrom;
148163 for(i=0, pFrom=pTabList->a; i<pTabList->nSrc; i++, pFrom++){
148164 Table *pTab = pFrom->pTab;
148168 Select *pSel = pFrom->pSelect;
150589 sqlite3SrcListDelete(db, pTmp->pFrom);
151099 SrcList *pFrom, /* FROM clause for an UPDATE-FROM, or NULL */
151114 pTriggerStep->pFrom = pFrom;
151117 pFrom = 0;
151121 pTriggerStep->pFrom = sqlite3SrcListDup(db, pFrom, EXPRDUP_REDUCE);
151127 sqlite3SrcListDelete(db, pFrom);
151433 if( pStep->pFrom ){
151434 SrcList *pDup = sqlite3SrcListDup(db, pStep->pFrom, 0);
151702 ** Parse context structure pFrom has just been used to create a sub-vdbe
151704 ** from pFrom to pTo.
151706 static void transferParseError(Parse *pTo, Parse *pFrom){
151707 assert( pFrom->zErrMsg==0 || pFrom->nErr );
151710 pTo->zErrMsg = pFrom->zErrMsg;
151711 pTo->nErr = pFrom->nErr;
151712 pTo->rc = pFrom->rc;
151714 sqlite3DbFree(pFrom->db, pFrom->zErrMsg);
159923 SrcList *pFrom, /* The FROM clause */
159926 int j /* Start looking with the j-th pFrom entry */
159932 iCur = pFrom->a[j].iCursor;
159933 for(pIdx=pFrom->a[j].pTab->pIndex; pIdx; pIdx=pIdx->pNext){
159947 }while( ++j < pFrom->nSrc );
159951 SrcList *pFrom, /* The FROM clause */
159975 for(i=0; i<pFrom->nSrc; i++){
159977 for(pIdx=pFrom->a[i].pTab->pIndex; pIdx; pIdx=pIdx->pNext){
159979 return exprMightBeIndexed2(pFrom,aiCurCol,pExpr,i);
163205 static int whereLoopXfer(sqlite3 *db, WhereLoop *pTo, WhereLoop *pFrom){
163207 if( pFrom->nLTerm > pTo->nLSlot
163208 && whereLoopResize(db, pTo, pFrom->nLTerm)
163213 memcpy(pTo, pFrom, WHERE_LOOP_XFER_SZ);
163214 memcpy(pTo->aLTerm, pFrom->aLTerm, pTo->nLTerm*sizeof(pTo->aLTerm[0]));
163215 if( pFrom->wsFlags & WHERE_VIRTUALTABLE ){
163216 pFrom->u.vtab.needFree = 0;
163217 }else if( (pFrom->wsFlags & WHERE_AUTO_INDEX)!=0 ){
163218 pFrom->u.btree.pIndex = 0;
165966 WherePath *pFrom; /* An element of aFrom[] that we are working on */
166004 for(ii=mxChoice*2, pFrom=aTo; ii>0; ii--, pFrom++, pX += nLoop){
166005 pFrom->aLoop = pX;
166043 for(ii=0, pFrom=aFrom; ii<nFrom; ii++, pFrom++){
166045 LogEst nOut; /* Rows visited by (pFrom+pWLoop) */
166046 LogEst rCost; /* Cost of path (pFrom+pWLoop) */
166047 LogEst rUnsorted; /* Unsorted cost of (pFrom+pWLoop) */
166048 i8 isOrdered; /* isOrdered for (pFrom+pWLoop) */
166052 if( (pWLoop->prereq & ~pFrom->maskLoop)!=0 ) continue;
166053 if( (pWLoop->maskSelf & pFrom->maskLoop)!=0 ) continue;
166054 if( (pWLoop->wsFlags & WHERE_AUTO_INDEX)!=0 && pFrom->nRow<3 ){
166065 rUnsorted = sqlite3LogEstAdd(pWLoop->rSetup,pWLoop->rRun + pFrom->nRow);
166066 rUnsorted = sqlite3LogEstAdd(rUnsorted, pFrom->rUnsorted);
166067 nOut = pFrom->nRow + pWLoop->nOut;
166068 maskNew = pFrom->maskLoop | pWLoop->maskSelf;
166069 isOrdered = pFrom->isOrdered;
166073 pWInfo->pOrderBy, pFrom, pWInfo->wctrlFlags,
166076 revMask = pFrom->revLoop;
166129 wherePathName(pFrom, iLoop, pWLoop), rCost, nOut, rUnsorted,
166148 wherePathName(pFrom, iLoop, pWLoop), rCost, nOut, rUnsorted,
166172 wherePathName(pFrom, iLoop, pWLoop), rCost, nOut, rUnsorted,
166190 wherePathName(pFrom, iLoop, pWLoop), rCost, nOut, rUnsorted,
166199 pTo->maskLoop = pFrom->maskLoop | pWLoop->maskSelf;
166205 memcpy(pTo->aLoop, pFrom->aLoop, sizeof(WhereLoop*)*iLoop);
166241 pFrom = aTo;
166243 aFrom = pFrom;
166253 /* Find the lowest cost path. pFrom will be left pointing to that path */
166254 pFrom = aFrom;
166256 if( pFrom->rCost>aFrom[ii].rCost ) pFrom = &aFrom[ii];
166262 pLevel->pWLoop = pWLoop = pFrom->aLoop[iLoop];
166272 int rc = wherePathSatisfiesOrderBy(pWInfo, pWInfo->pResultSet, pFrom,
166273 WHERE_DISTINCTBY, nLoop-1, pFrom->aLoop[nLoop-1], ¬Used);
166280 pWInfo->nOBSat = pFrom->isOrdered;
166282 if( pFrom->isOrdered==pWInfo->pOrderBy->nExpr ){
166290 pWInfo->revMask = pFrom->revLoop;
166294 u32 wsFlags = pFrom->aLoop[nLoop-1]->wsFlags;
166299 int rc = wherePathSatisfiesOrderBy(pWInfo, pWInfo->pOrderBy, pFrom,
166300 WHERE_ORDERBY_LIMIT, nLoop-1, pFrom->aLoop[nLoop-1], &m);
166321 pFrom, 0, nLoop-1, pFrom->aLoop[nLoop-1], &revMask
166332 pWInfo->nRowOut = pFrom->nRow;
174869 SrcList *pFrom;
174873 pFrom = sqlite3SrcListAppendFromTerm(pParse,0,0,0,&x,pRhs,0);
174874 pRhs = sqlite3SelectNew(pParse,0,pFrom,0,0,0,0,0,0);
196135 static int fts3SegReaderRequire(Fts3SegReader *pReader, char *pFrom, int nByte){
196138 || (pFrom>=pReader->aNode && pFrom<&pReader->aNode[pReader->nNode])
196141 && (pFrom - pReader->aNode + nByte)>pReader->nPopulate