19146     sqlite3_mutex_methods *pTo = &sqlite3GlobalConfig.mutex;
19153     memcpy(pTo, pFrom, offsetof(sqlite3_mutex_methods, xMutexAlloc));
19154     memcpy(&pTo->xMutexFree, &pFrom->xMutexFree,
19155            sizeof(*pTo) - offsetof(sqlite3_mutex_methods, xMutexFree));
19156     pTo->xMutexAlloc = pFrom->xMutexAlloc;
59614 ** on page pFrom to page pTo. If page pFrom was not a leaf page, then
59616 ** parent page stored in the pointer map is page pTo. If pFrom contained
59618 ** map entries are also updated so that the parent page is page pTo.
59621 ** MemPage.apOvfl[] array), they are not copied to pTo. 
59623 ** Before returning, page pTo is reinitialized using btreeInitPage().
59629 static void copyNodeContent(MemPage *pFrom, MemPage *pTo, int *pRC){
59633     u8 * const aTo = pTo->aData;
59635     int const iToHdr = ((pTo->pgno==1) ? 100 : 0);
59644     /* Copy the b-tree node content from page pFrom to page pTo. */
59649     /* Reinitialize page pTo so that the contents of the MemPage structure
59650     ** match the new data. The initialization of pTo can actually fail under
59654     pTo->isInit = 0;
59655     rc = btreeInitPage(pTo);
59662     ** for any b-tree or overflow pages that pTo now contains the pointers to.
59665       *pRC = setChildPtrmaps(pTo);
63032 ** The size of file pTo may be reduced by this operation. If anything 
63033 ** goes wrong, the transaction on pTo is rolled back. If successful, the 
63036 SQLITE_PRIVATE int sqlite3BtreeCopyFile(Btree *pTo, Btree *pFrom){
63038   sqlite3_file *pFd;              /* File descriptor for database pTo */
63040   sqlite3BtreeEnter(pTo);
63043   assert( sqlite3BtreeIsInTrans(pTo) );
63044   pFd = sqlite3PagerFile(sqlite3BtreePager(pTo));
63060   b.pDest = pTo;
63074     pTo->pBt->btsFlags &= ~BTS_PAGESIZE_FIXED;
63079   assert( sqlite3BtreeIsInTrans(pTo)==0 );
63082   sqlite3BtreeLeave(pTo);
63865 ** Make an shallow copy of pFrom into pTo.  Prior contents of
63866 ** pTo are freed.  The pFrom->z field is not duplicated.  If
63867 ** pFrom->z is used, then pTo->z points to the same thing as pFrom->z
63870 SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int srcType){
63872   assert( pTo->db==pFrom->db );
63873   if( VdbeMemDynamic(pTo) ) vdbeMemClearExternAndSetNull(pTo);
63874   memcpy(pTo, pFrom, MEMCELLSIZE);
63876     pTo->flags &= ~(MEM_Dyn|MEM_Static|MEM_Ephem);
63878     pTo->flags |= srcType;
63883 ** Make a full copy of pFrom into pTo.  Prior contents of pTo are
63886 SQLITE_PRIVATE int sqlite3VdbeMemCopy(Mem *pTo, const Mem *pFrom){
63889   assert( pTo->db==pFrom->db );
63891   if( VdbeMemDynamic(pTo) ) vdbeMemClearExternAndSetNull(pTo);
63892   memcpy(pTo, pFrom, MEMCELLSIZE);
63893   pTo->flags &= ~MEM_Dyn;
63894   if( pTo->flags&(MEM_Str|MEM_Blob) ){
63896       pTo->flags |= MEM_Ephem;
63897       rc = sqlite3VdbeMemMakeWriteable(pTo);
63905 ** Transfer the contents of pFrom to pTo. Any existing value in pTo is
63910 SQLITE_PRIVATE void sqlite3VdbeMemMove(Mem *pTo, Mem *pFrom){
63912   assert( pTo->db==0 || sqlite3_mutex_held(pTo->db->mutex) );
63913   assert( pFrom->db==0 || pTo->db==0 || pFrom->db==pTo->db );
63915   sqlite3VdbeMemRelease(pTo);
63916   memcpy(pTo, pFrom, sizeof(Mem));
70378   Vdbe *pTo = (Vdbe*)pToStmt;
70380   assert( pTo->db==pFrom->db );
70381   assert( pTo->nVar==pFrom->nVar );
70382   sqlite3_mutex_enter(pTo->db->mutex);
70384     sqlite3VdbeMemMove(&pTo->aVar[i], &pFrom->aVar[i]);
70386   sqlite3_mutex_leave(pTo->db->mutex);
70405   Vdbe *pTo = (Vdbe*)pToStmt;
70406   if( pFrom->nVar!=pTo->nVar ){
70409   if( pTo->isPrepareV2 && pTo->expmask ){
70410     pTo->expired = 1;
88400 ** Copy the contents of object (*pFrom) into (*pTo).
88403 static void sampleCopy(Stat4Accum *p, Stat4Sample *pTo, Stat4Sample *pFrom){
88404   pTo->isPSample = pFrom->isPSample;
88405   pTo->iCol = pFrom->iCol;
88406   pTo->iHash = pFrom->iHash;
88407   memcpy(pTo->anEq, pFrom->anEq, sizeof(tRowcnt)*p->nCol);
88408   memcpy(pTo->anLt, pFrom->anLt, sizeof(tRowcnt)*p->nCol);
88409   memcpy(pTo->anDLt, pFrom->anDLt, sizeof(tRowcnt)*p->nCol);
88411     sampleSetRowid(p->db, pTo, pFrom->nRowid, pFrom->u.aRowid);
88413     sampleSetRowidInt64(p->db, pTo, pFrom->u.iRowid);
93349 ** connect the key to the last column inserted.  pTo is the name of
93351 ** of tables in the parent pTo table.  flags contains all
93364   Token *pTo,          /* Name of the other table */
93378   assert( pTo!=0 );
93386          p->aCol[iCol].zName, pTo);
93398   nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1;
93412   memcpy(z, pTo->z, pTo->n);
93413   z[pTo->n] = 0;
93415   z += pTo->n+1;
99104     Table *pTo;                   /* Parent table of foreign key pFKey */
99105     Index *pIdx = 0;              /* Index on key columns in pTo */
99124       pTo = sqlite3FindTable(db, pFKey->zTo, zDb);
99126       pTo = sqlite3LocateTable(pParse, 0, pFKey->zTo, zDb);
99128     if( !pTo || sqlite3FkLocateIndex(pParse, pTo, pFKey, &pIdx, &aiFree) ){
99131       if( pTo==0 ){
99167         char *zCol = pTo->aCol[pIdx ? pIdx->aiColumn[i] : pTo->iPKey].zName;
99168         rcauth = sqlite3AuthReadCol(pParse, pTo->zName, zCol, iDb);
99177     sqlite3TableLock(pParse, iDb, pTo->tnum, 0, pTo->zName);
99184       fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regOld, -1, bIgnore);
99195       fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regNew, +1, bIgnore);
113067 ** from pFrom to pTo.
113069 static void transferParseError(Parse *pTo, Parse *pFrom){
113071   assert( pTo->zErrMsg==0 || pTo->nErr );
113072   if( pTo->nErr==0 ){
113073     pTo->zErrMsg = pFrom->zErrMsg;
113074     pTo->nErr = pFrom->nErr;
113075     pTo->rc = pFrom->rc;
120450 static int whereLoopXfer(sqlite3 *db, WhereLoop *pTo, WhereLoop *pFrom){
120451   whereLoopClearUnion(db, pTo);
120452   if( whereLoopResize(db, pTo, pFrom->nLTerm) ){
120453     memset(&pTo->u, 0, sizeof(pTo->u));
120456   memcpy(pTo, pFrom, WHERE_LOOP_XFER_SZ);
120457   memcpy(pTo->aLTerm, pFrom->aLTerm, pTo->nLTerm*sizeof(pTo->aLTerm[0]));
122129   WherePath *pTo;           /* An element of aTo[] that we are working on */
122252         ** The term "((pTo->isOrdered^isOrdered)&0x80)==0" is equivalent
122253         ** to (pTo->isOrdered==(-1))==(isOrdered==(-1))" for the range
122256         for(jj=0, pTo=aTo; jj<nTo; jj++, pTo++){
122257           if( pTo->maskLoop==maskNew
122258            && ((pTo->isOrdered^isOrdered)&0x80)==0
122290           pTo = &aTo[jj];
122299           /* Control reaches here if best-so-far path pTo=aTo[jj] covers the
122302           ** pTo or if the candidate should be skipped */
122303           if( pTo->rCost<rCost || (pTo->rCost==rCost && pTo->nRow<=nOut) ){
122311                   wherePathName(pTo, iLoop+1, 0), pTo->rCost, pTo->nRow,
122312                   pTo->isOrdered>=0 ? pTo->isOrdered+'0' : '?');
122316             testcase( pTo->rCost==rCost );
122319           testcase( pTo->rCost==rCost+1 );
122321           ** pTo path.  Replace pTo with the candidate. */
122329                 wherePathName(pTo, iLoop+1, 0), pTo->rCost, pTo->nRow,
122330                 pTo->isOrdered>=0 ? pTo->isOrdered+'0' : '?');
122335         pTo->maskLoop = pFrom->maskLoop | pWLoop->maskSelf;
122336         pTo->revLoop = revMask;
122337         pTo->nRow = nOut;
122338         pTo->rCost = rCost;
122339         pTo->rUnsorted = rUnsorted;
122340         pTo->isOrdered = isOrdered;
122341         memcpy(pTo->aLoop, pFrom->aLoop, sizeof(WhereLoop*)*iLoop);
122342         pTo->aLoop[iLoop] = pWLoop;
122347           for(jj=1, pTo=&aTo[1]; jj<mxChoice; jj++, pTo++){
122348             if( pTo->rCost>mxCost 
122349              || (pTo->rCost==mxCost && pTo->rUnsorted>mxUnsorted) 
122351               mxCost = pTo->rCost;
122352               mxUnsorted = pTo->rUnsorted;
122363       for(ii=0, pTo=aTo; ii<nTo; ii++, pTo++){
122365            wherePathName(pTo, iLoop+1, 0), pTo->rCost, pTo->nRow,
122366            pTo->isOrdered>=0 ? (pTo->isOrdered+'0') : '?');
122367         if( pTo->isOrdered>0 ){
122368           sqlite3DebugPrintf(" rev=0x%llx\n", pTo->revLoop);

Indexes created Fri Jan 08 05:29:00 CET 2016