lib/sqlite/sqlite3.c

16812     sqlite3_mutex_methods *pTo = &sqlite3GlobalConfig.mutex;
16819     memcpy(pTo, pFrom, offsetof(sqlite3_mutex_methods, xMutexAlloc));
16820     memcpy(&pTo->xMutexFree, &pFrom->xMutexFree,
16821            sizeof(*pTo) - offsetof(sqlite3_mutex_methods, xMutexFree));
16822     pTo->xMutexAlloc = pFrom->xMutexAlloc;
54015 ** on page pFrom to page pTo. If page pFrom was not a leaf page, then
54017 ** parent page stored in the pointer map is page pTo. If pFrom contained
54019 ** map entries are also updated so that the parent page is page pTo.
54022 ** MemPage.aOvfl[] array), they are not copied to pTo.
54024 ** Before returning, page pTo is reinitialized using btreeInitPage().
54030 static void copyNodeContent(MemPage *pFrom, MemPage *pTo, int *pRC){
54034     u8 * const aTo = pTo->aData;
54036     int const iToHdr = ((pTo->pgno==1) ? 100 : 0);
54045     /* Copy the b-tree node content from page pFrom to page pTo. */
54050     /* Reinitialize page pTo so that the contents of the MemPage structure
54051     ** match the new data. The initialization of pTo can actually fail under
54055     pTo->isInit = 0;
54056     rc = btreeInitPage(pTo);
54063     ** for any b-tree or overflow pages that pTo now contains the pointers to.
54066       *pRC = setChildPtrmaps(pTo);
57111 ** The size of file pTo may be reduced by this operation. If anything
57112 ** goes wrong, the transaction on pTo is rolled back. If successful, the
57115 SQLITE_PRIVATE int sqlite3BtreeCopyFile(Btree *pTo, Btree *pFrom){
57118   sqlite3BtreeEnter(pTo);
57129   b.pDest = pTo;
57143     pTo->pBt->pageSizeFixed = 0;
57147   sqlite3BtreeLeave(pTo);
57761 ** Make an shallow copy of pFrom into pTo.  Prior contents of
57762 ** pTo are freed.  The pFrom->z field is not duplicated.  If
57763 ** pFrom->z is used, then pTo->z points to the same thing as pFrom->z
57766 SQLITE_PRIVATE void sqlite3VdbeMemShallowCopy(Mem *pTo, const Mem *pFrom, int srcType){
57768   MemReleaseExt(pTo);
57769   memcpy(pTo, pFrom, MEMCELLSIZE);
57770   pTo->xDel = 0;
57772     pTo->flags &= ~(MEM_Dyn|MEM_Static|MEM_Ephem);
57774     pTo->flags |= srcType;
57779 ** Make a full copy of pFrom into pTo.  Prior contents of pTo are
57782 SQLITE_PRIVATE int sqlite3VdbeMemCopy(Mem *pTo, const Mem *pFrom){
57786   MemReleaseExt(pTo);
57787   memcpy(pTo, pFrom, MEMCELLSIZE);
57788   pTo->flags &= ~MEM_Dyn;
57790   if( pTo->flags&(MEM_Str|MEM_Blob) ){
57792       pTo->flags |= MEM_Ephem;
57793       rc = sqlite3VdbeMemMakeWriteable(pTo);
57801 ** Transfer the contents of pFrom to pTo. Any existing value in pTo is
57806 SQLITE_PRIVATE void sqlite3VdbeMemMove(Mem *pTo, Mem *pFrom){
57808   assert( pTo->db==0 || sqlite3_mutex_held(pTo->db->mutex) );
57809   assert( pFrom->db==0 || pTo->db==0 || pFrom->db==pTo->db );
57811   sqlite3VdbeMemRelease(pTo);
57812   memcpy(pTo, pFrom, sizeof(Mem));
62765   Vdbe *pTo = (Vdbe*)pToStmt;
62767   assert( pTo->db==pFrom->db );
62768   assert( pTo->nVar==pFrom->nVar );
62769   sqlite3_mutex_enter(pTo->db->mutex);
62771     sqlite3VdbeMemMove(&pTo->aVar[i], &pFrom->aVar[i]);
62773   sqlite3_mutex_leave(pTo->db->mutex);
62792   Vdbe *pTo = (Vdbe*)pToStmt;
62793   if( pFrom->nVar!=pTo->nVar ){
62796   if( pTo->isPrepareV2 && pTo->expmask ){
62797     pTo->expired = 1;
81305 ** connect the key to the last column inserted.  pTo is the name of
81307 ** pTo table that the foreign key points to.  flags contains all
81320   Token *pTo,          /* Name of the other table */
81334   assert( pTo!=0 );
81342          p->aCol[iCol].zName, pTo);
81354   nByte = sizeof(*pFKey) + (nCol-1)*sizeof(pFKey->aCol[0]) + pTo->n + 1;
81368   memcpy(z, pTo->z, pTo->n);
81369   z[pTo->n] = 0;
81371   z += pTo->n+1;
86379     Table *pTo;                   /* Parent table of foreign key pFKey */
86380     Index *pIdx = 0;              /* Index on key columns in pTo */
86392       pTo = sqlite3FindTable(db, pFKey->zTo, zDb);
86394       pTo = sqlite3LocateTable(pParse, 0, pFKey->zTo, zDb);
86396     if( !pTo || locateFkeyIndex(pParse, pTo, pFKey, &pIdx, &aiFree) ){
86399       if( pTo==0 ){
86435         char *zCol = pTo->aCol[pIdx ? pIdx->aiColumn[i] : pTo->iPKey].zName;
86436         rcauth = sqlite3AuthReadCol(pParse, pTo->zName, zCol, iDb);
86445     sqlite3TableLock(pParse, iDb, pTo->tnum, 0, pTo->zName);
86452       fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regOld, -1,isIgnore);
86457       fkLookupParent(pParse, iDb, pTo, pIdx, pFKey, aiCol, regNew, +1,isIgnore);
97931 ** from pFrom to pTo.
97933 static void transferParseError(Parse *pTo, Parse *pFrom){
97935   assert( pTo->zErrMsg==0 || pTo->nErr );
97936   if( pTo->nErr==0 ){
97937     pTo->zErrMsg = pFrom->zErrMsg;
97938     pTo->nErr = pFrom->nErr;